分布式系统中通过redis生成自增长唯一id 号

最新推荐文章于 2024-05-30 08:41:13 发布
最新推荐文章于 2024-05-30 08:41:13 发布
阅读量1.8k 收藏 5
点赞数
分类专栏： Redis 项目应用 文章标签： redis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/youaremy1bestlove/article/details/122047021
版权

前言：在分布式环境中数据分库分表后通过数据库自增加是无法保证id的唯 一性，这个时候可以利用Redis 的数自增长原子操作来实现id的唯一。

需要意点：每个id号的起始值初始化，防止分布式环境中一个服务操作导致已初始化的起始值重新被初始化，这样后果会导致id生成重复。

好了，不说这么多了，上代码：

application.properties

#reids config
spring.redis.host=redis.XXXXXX.local.host
spring.redis.password=XXXXXX
spring.redis.port=6379

spring.redis.pool.max-idle=8
spring.redis.pool.min-idle=0
spring.redis.pool.max-active=8
spring.redis.pool.max-wait=-1
spring.redis.timeout=20000

pom.xml

<!-- redis -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
			<version>1.5.13.RELEASE</version>
		</dependency>
RedisConfig
package com.myproject.config;

import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.TypeResolverBuilder;
import com.myproject.service.RedisIdService;
import com.myproject.util.RedisIdUtils;
import com.myproject.util.SpringContextHolder;
import org.springframework.context.ApplicationContext;
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.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;

import javax.annotation.Resource;

@Configuration
public class RedisConfig {

	@Resource
	private RedisConnectionFactory redisConnectionFactory;

	/**
	 * redis缓存管理模板
	 *
	 * @return RedisTemplate
	 */
	@Bean("redisTemplateCustomize")
	public RedisTemplate<String, Object> redisTemplate(Jackson2ObjectMapperBuilder jackson2ObjectMapperBuilder) {
		ObjectMapper objectMapper = jackson2ObjectMapperBuilder.build();

		TypeResolverBuilder<?> defaultTyping = new ObjectMapper.DefaultTypeResolverBuilder(ObjectMapper.DefaultTyping.NON_FINAL);
		defaultTyping = defaultTyping.init(JsonTypeInfo.Id.CLASS, null);
		defaultTyping = defaultTyping.inclusion(JsonTypeInfo.As.PROPERTY);
		objectMapper.setDefaultTyping(defaultTyping);

		StringRedisSerializer keySerializer = new StringRedisSerializer();
		GenericJackson2JsonRedisSerializer valueSerializer = new GenericJackson2JsonRedisSerializer(objectMapper);

		RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
		redisTemplate.setConnectionFactory(redisConnectionFactory);
		redisTemplate.setEnableDefaultSerializer(false);
		redisTemplate.setKeySerializer(keySerializer);
		redisTemplate.setValueSerializer(valueSerializer);
		redisTemplate.setHashKeySerializer(keySerializer);
		redisTemplate.setHashValueSerializer(valueSerializer);
		return redisTemplate;
	}

	@Bean
	public SpringContextHolder springContextHolder(ApplicationContext applicationContext){
		SpringContextHolder contextHolder=  new SpringContextHolder();
		contextHolder.setApplicationContext(applicationContext);

		RedisIdService redisIdService = (RedisIdService) SpringContextHolder.getBean("redisIdService");
		RedisIdUtils.init(redisIdService);
		return contextHolder;
	}
}
RedisIdUtils
package com.myproject.util;

import com.myproject.constant.CommonConstant;
 
import com.myproject.service.RedisIdService;
import lombok.extern.slf4j.Slf4j;

/**
 * <h3>myproject</h3>
 * <p>redis 自增长id公共类</p>
 *
 * @Author :  krics
 * @Date : 2021-12-15 10:52
 **/
@Slf4j
public class RedisIdUtils {

    private  static RedisIdService redisIdService  ;
    private   RedisIdUtils(){
        throw new IllegalStateException("Utility class");
    }

    public static void init(RedisIdService redisIdService){
        RedisIdUtils.redisIdService = redisIdService;
    }

    /**
     * 获取下一个sid
     * @param redisIdKey redis 生成业务id KEY
     * @return 新的序列号
     */
    public static long nextId(CommonConstant.RedisIdKeyEnum redisIdKey){
        if(null == redisIdKey){
            log.warn("Redis KEY 不存在");
            return CommonConstant.DEFAULT_NUMBER_ZERO;
        }
       return redisIdService.nextId(redisIdKey);
    }

}

/**
 * <h3>redis-id-utils</h3>
 * <p>redis 自增长id公共类</p>
 *
 * @Author :  krics
 * @Date : 2021-12-15 10:52
 **/
@Slf4j
public class RedisIdUtils {

    private  static RedisIdService redisIdService  ;
    private   RedisIdUtils(){
        throw new IllegalStateException("Utility class");
    }

    public static void init(RedisIdService redisIdService){
        RedisIdUtils.redisIdService = redisIdService;
    }

    /**
     * 获取下一个sid
     * @param redisIdKey redis 生成业务id KEY
     * @return 新的序列号
     */
    public static long nextId(CommonConstant.RedisIdKeyEnum redisIdKey){
        if(null == redisIdKey){
            log.warn("Redis KEY 不存在");
            return SHConstant.DEFALUT_NUMBER_ZERO;
        }
       return redisIdService.nextId(redisIdKey);
    }

}

RedisIdService
package com.myproject.service;

import com.myprojectg.constant.CommonConstant;
import com.myproject.util.RedisLock;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateUtils;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.support.atomic.RedisAtomicLong;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.text.ParseException;
import java.util.Arrays;
import java.util.Date;
import java.util.Optional;
import java.util.concurrent.TimeUnit;

/**
 * <h3>myproject</h3>
 * <p>Redis分布式id</p>
 *
 * @Author : krics
 * @Date : 2021-12-13 17:22
 **/
@Slf4j
@Component
public class RedisIdService {

    @Resource
    private RedisTemplate redisTemplate;
    @Resource
    private  RedisLock redisLock;



    /**
     * 服务启动时初始化对应业务ID值。
     */
    @PostConstruct
    private  void init(){
        Arrays.asList(CommonConstant.RedisIdKeyEnum.values()).stream().parallel().forEach(redisIdKey -> {
            //初始化Redis 相关业务自增加id初始值
            executeInitValue(redisIdKey);
        });
    }
    //如果对应业务未执行初始化，则加锁初始化
    private void executeInitValue(CommonConstant.RedisIdKeyEnum redisIdKey){
        //业务主键Redis KEY
        String key = redisIdKey.getKey();
        //业务主键是否初始化标记KEY
        String initStatusKey = getInitStatusKey(key);
        if(!redisTemplate.hasKey(initStatusKey)){
            log.info("Redis KEY:{} 准许备初始化",redisIdKey.getKey());
            //首次初始化时分布式锁KEY
            String lockKey = getInitKey(key);
            boolean lockSuccess = false;
            try{
                 //分布式锁
                lockSuccess =  redisLock.lock(lockKey,2,10,2);
                //设置初始条件是获取锁且未被初始化
                if(lockSuccess && !redisTemplate.hasKey(initStatusKey)){
                    String  initValueKey = getInitValueKey(key);
                    //枚举类默认起始值
                    long initValue = redisIdKey.getInitialValue();
                    if(redisTemplate.hasKey(initValueKey)){
                        //redis 指定了默认初始化值，则优先使用redis中（方便日后生成id区间段刷新调整）
                        initValue = Long.valueOf(Optional.ofNullable((String)redisTemplate.opsForValue().get(initValueKey)).orElse("0"));
                    }
                    log.info("准许备初始化 Redis KEY:{} ,起始值:{}",redisIdKey.getKey(),initValue);
                    set(key,initValue,getExpireTime());
                    //设置对应业务初始化标志为已初始化
                    redisTemplate.opsForSet().add(initStatusKey,Boolean.TRUE);
                }
            }finally {
                if(lockSuccess){
                    redisLock.unlock();
                }
            }
        }
    }
    /**
     * @param key
     * @param initValue
     * @param expireTime
     * @Title: set
     * @Description: set cache.
     */
    public void set(String key, long initValue, Date expireTime) {
        //初始化基础id
        RedisAtomicLong counter =   new RedisAtomicLong(key, redisTemplate.getConnectionFactory(),initValue);
        //设置过期时间
        counter.expireAt(expireTime);
    }

    /**
     * redisIdKey redis 生成id key
     * @param redisIdKey
     * @return
     */
    public long nextId(CommonConstant.RedisIdKeyEnum redisIdKey) {
        RedisAtomicLong counter  =   new RedisAtomicLong(redisIdKey.getKey(), redisTemplate.getConnectionFactory());;
        long nextId = counter.incrementAndGet();
        log.info("next id:{}",nextId);
        return nextId;
    }
    /**
     * 获取指定KEY 当前最大的ID
     * @param key
     * @return
     */
    public long getCureentId(String key) {
        RedisAtomicLong counter = new RedisAtomicLong(key, redisTemplate.getConnectionFactory());
        return counter.get();
    }
    public String getInitValueKey(String key){
        return StringUtils.join("InitValue:",key);
    }
    private String getInitKey(String key){
        return StringUtils.join("Init:",key);
   }
    private String getInitStatusKey(String key){
        return StringUtils.join("Init:Status:",key);
    }

    /**
     * 获取redis过期时间
     * @return
     */
    private   Date getExpireTime() {
        Date maxExpireTime = null;
        try {
              maxExpireTime =   DateUtils.parseDate(CommonConstant.MAX_EXPIRED_TIME,CommonConstant.PATTERN_DATE_YYYY_MM_DD);
        } catch (ParseException e) {
            log.error("getExpireTime exception:",e);
        }

        return maxExpireTime;
    }
    /**
     * 删除指定KEY ID的缓存值。
     * @param key
     */
    public void deleteAtomicLong(String key) {
        RedisAtomicLong entityIdCounter = new RedisAtomicLong(key, redisTemplate.getConnectionFactory());
        entityIdCounter.expire(0, TimeUnit.MILLISECONDS);
        //删除已初始化标志
        redisTemplate.delete(getInitStatusKey(key));

    }

}

RedisLock
package com.project.util;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisConnectionUtils;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import redis.clients.jedis.Jedis;

import javax.annotation.Resource;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

@Slf4j
@Service
public class RedisLock {

    @Resource(name = "stringRedisTemplate")
    private StringRedisTemplate redisTemplate;

    private static final String LOCK_SUCCESS = "OK";
    private static final String SET_IF_NOT_EXIST = "NX";
    private static final String SET_WITH_EXPIRE_TIME = "PX";
    private static final Long RELEASE_SUCCESS = 1L;

    private static final String THREAD_KEY_VALUE = "value";
    private static final String THREAD_KEY_TIMES = "times";
    private static final String THREAD_KEY_KEY = "key";
    private static final String THREAD_KEY_RETRY = "retry";
    private static final String THREAD_KEY_EXPIRE_SECS = "expireSecs";
    private static final String THREAD_KEY_SLEEP_SECS = "sleepSecs";

    private ThreadLocal<Map<String, Object>> local = new ThreadLocal<>();

    public boolean lock(String key, final int retry, long expireSecs, long sleepSecs) {
        log.info("开启Redis分布式锁");
        Map<String, Object> params = new HashMap<>();
        params.put(THREAD_KEY_KEY, key);
        params.put(THREAD_KEY_RETRY, retry);
        params.put(THREAD_KEY_EXPIRE_SECS, expireSecs);
        params.put(THREAD_KEY_SLEEP_SECS, sleepSecs);
        params.put(THREAD_KEY_TIMES, 0);
        local.set(params);
        return this.lock();
    }

    public void unlock() {
        RedisConnectionFactory factory = redisTemplate.getConnectionFactory();
        RedisConnection conn = factory.getConnection();
        try {
            if (null != local.get()) {
                String key = String.valueOf(local.get().get(THREAD_KEY_KEY));
                String value = String.valueOf(local.get().get(THREAD_KEY_VALUE));
                if (StringUtils.isNotBlank(key) && redisTemplate.hasKey(key)) {
                    Jedis jedis = (Jedis) conn.getNativeConnection();
                    String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
                    Object result = jedis.eval(script, Collections.singletonList(key), Collections.singletonList(value));
                    if (RELEASE_SUCCESS.equals(result)) {
                        log.info("Redis分布式锁,释放锁成功！");
                    } else {
                        log.info("Redis分布式锁,释放锁失败！");
                    }
                }
            }
        } finally {
            RedisConnectionUtils.releaseConnection(conn, factory);
        }
    }

    private boolean lock() {
        long sleepSecs = Long.parseLong(String.valueOf(local.get().get(THREAD_KEY_SLEEP_SECS)));
        int retry = Integer.parseInt(String.valueOf(local.get().get(THREAD_KEY_RETRY)));
        log.info("加锁尝试次数：" + retry + ",每次间隔时间(s):" + sleepSecs);
        int times = Integer.parseInt(local.get().get(THREAD_KEY_TIMES).toString());
        if (!tryLock()) {
            try {
                Thread.sleep(sleepSecs * 1000);
            } catch (InterruptedException e) {
                log.error("Redis分布式锁休眠异常", e);
                Thread.currentThread().interrupt();
            }
            times++;
            local.get().put(THREAD_KEY_TIMES, times);
            if (retry == times) {
                log.info("Redis分布式锁,加锁失败！");
                return false;
            }
            return lock();
        }
        return true;
    }

    private boolean tryLock() {
        RedisConnectionFactory factory = redisTemplate.getConnectionFactory();
        RedisConnection conn = factory.getConnection();
        try {
            Jedis jedis = (Jedis) conn.getNativeConnection();
            String key = String.valueOf(local.get().get(THREAD_KEY_KEY));
            String value = UUID.randomUUID().toString();
            local.get().put(THREAD_KEY_VALUE, value);
            long expireSecs = Long.parseLong(String.valueOf(local.get().get(THREAD_KEY_EXPIRE_SECS)));
            String ret = jedis.set(key, value, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, expireSecs * 1000);

            if (LOCK_SUCCESS.equals(ret)) {
                log.info("Redis分布式锁,加锁成功！");
                log.info("key:" + key + ",value:" + value + ",expire(s):" + expireSecs);
                return true;
            }
            return false;
        } finally {
            RedisConnectionUtils.releaseConnection(conn, factory);
        }

    }
}

CommonConstant
package com.pateo.qingcloud.tsp.remoteconfig.constant;

import lombok.Getter;

import java.util.Arrays;

/**
 * <h3>myProject</h3>
 * <p>常量定义</p>
 *
 * @Author :  krics
 * @Date : 2021-12-20 17:43
 **/
public interface CommonConstant {
       long  DEFAULT_NUMBER_ZERO = 0;
    //缓存过期时间
       String MAX_EXPIRED_TIME = "2099-12-30 23:59:59";
       String PATTERN_DATE_YYYY_MM_DD = "yyyy-MM-dd HH:mm:ss";
    @Getter
       enum RedisIdKeyEnum{
        SYS_LOG_ID_KEY("Redis:ID:SysLog",1000000000000000L,"系统日志起始id"),
        SYS_LOGIN_LOGIN_ID_KEY("Redis:ID:SysLoginLog",200000000000000L,"系统登录日志起始id");
        private String key;
        private  long initialValue;
        private String desc;

        RedisIdKeyEnum(String code,long initialValue, String desc){
            this.key = code;
            this.initialValue = initialValue;
            this.desc = desc;
        }
    }
      static  RedisIdKeyEnum getRedisIdKeyByKey(String key){
        return Arrays.asList(RedisIdKeyEnum.values()).stream()
                .filter(redisIdKey -> redisIdKey.getKey().equals(key))
                .findFirst().orElse(null);
    }
}

使用：

long nextId = RedisIdUtils.nextId(CommonConstant.RedisIdKeyEnum.SYS_LOG_ID_KEY);

miss味道
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【REDIS生成分布式环境下自增ID】
qq_61540471的博客
06-10 321
springboot引入依赖 配置文件 首先写一个由今天生成id的方法结束递增的时间的方法获取当前时间方法在controller中调用写的方法在调用方法日期后数字不断递增
Redis自增生成
qq_41194023的博客
04-28 3927
Redis 是一个开源的内存数据结构存储系统，可以用来作为数据库、缓存和消息中间件。Redis 的特点是高性能、可扩展性强，支持多种数据结构等。在使用 Redis 时，常常需要用到自增 ID 的功能，例如生成订单 ID 等。本文将介绍如何使用 Java 实现 Redis 自增生成 ID 的功能。本文介绍了如何将 Redis 自增生成 ID 封装成一个工具类。通过封装，可以更方便地使用 Redis 自增生成 ID 的功能，并且避免了重复代码的出现。
Redis实现全局唯一id
最新发布
时间如瑾 代码如诗
05-30 977
ID 生成器在微博我们一直叫发号器，微博就是用这样的号来存储，而我微博里讨论的时候也都是以发号器为标签。它的主要目的确如平常大家理解的“为一个分布式系统的数据object产生一个唯一的标识”，但其实在一个真实的系统里可能也可以承担更多的作用。唯一性时间相关粗略有序可反解可制造下面我会分别讲每个作用后面的考虑和权衡，也会对比介绍一下业界已知的几种 ID 设计。要唯一性，是否需要全局唯一？
Redis系列之实现分布式自增主键
Nicky's blog
11-09 682
使用Redis来实现分布式的主键自增主要是依赖于Redis的INCR命令，调用INCR命令的对应key，其数值是实现递增加一，所以利用这个性质，将redis独立部署起来就可以实现分布式环境的自增ID，如图，使用INCR命令的例子
手写基于redis-lua脚本实现分布式id生成器starter
qq_34905631的博客
04-23 1394
由于之前分享过一篇：百度开源分布式id生成器集成–真香警告里面提到了基于redis来实现一个分布式id生成器的思路，只是简单的说了下，本次分享就手写了一个。本文手写基于redis-lua脚本实现的分布式id生成器starter分享到此结束了，我把我手写的轮子开源出去，可以让java又多了一种分布式id生成的选择，解决了分布式id生成的问题，开源才能繁荣，通过本文的分享和之前文章的分享，在解决分布式id生成问题选择上丰富起来了，各种实现上基本都是类似和相通的，希望我的分享对你有所启发和帮助，请一键三连！
redis 实现分布式全局唯一id
小哇
06-02 3358
全局唯一id必须具备什么特点？ 1. 全局唯一性：不能出现重复的ID，最基本的要求。 2. 单调递增：保证下一个ID一定大于上一个ID。 3. 趋势递增：在一段时间内，生成的ID是递增的趋势。如：在一段时间内生成的ID在【0，1000】之间，过段时间生成的ID在【1000，2000】之间。 但在【0-1000】区间内的时候，ID生成有可能第一次是12，第二次是10，第三次是14。 4. 信息安全：如果ID是连续递增的，恶意用户就可以很容易的窥见订单号的规则，从而猜出下一个订单号， 如果是...
java使用redis递增
笑小枫
08-10 1962
如果key在redis中不存在，则会自动初始化生成key，并返回0。 public Long getIncr(String key){ RedisAtomicLong redisAtomicLong = new RedisAtomicLong(key, redisTemplate.getConnectionFactory()); return redisAtomicLong.getAndIncrement(); } ...
icicle：使用Redis和Lua的分布式k分类唯一ID生成系统
02-03
使用Redis和Lua的分布式k分类唯一ID生成系统。 Icicle是一个使用Redis的Lua脚本以分布式方式生成64位，k可排序唯一ID的项目。 可以使用和以任何语言编写Icicle的实现。 。 冰柱v1.x用户： v2.x中有一些重要的...
浅谈Redis在分布式系统中的协调性运用
09-10
本文将深入探讨Redis如何在分布式系统中发挥协调作用，尤其是在进程调度、线程管理和消息队列中的应用。 首先，Redis的单线程模型使其在处理数据结构时具有原子性，这为分布式锁的实现提供了基础。在分布式系统中，...
中小水电站分布式云监控的Redis可靠交互策略.pdf
08-08
【摘要】:本文提出了一种针对中小水电站的分布式云监控系统构建策略，利用Redis云架构和树莓派进行数据交互，确保系统的稳定运行。通过Python编程实现电站现场设备（如PLC控制器、测控仪表、继保装置和摄像头）的...
java web在高并发和分布式下实现订单号生成唯一的解决方案
08-28
在高并发和分布式下，实现订单号生成唯一是 Java Web 开发中的一大挑战。为了解决这个问题，我们需要从多方面考虑，包括时间戳、随机数、线程ID、进程ID、MAC 地址、IP 地址、CPU 序列号等。下面我们将详细介绍四种...
Redis思维导图分布式缓存-基于Redis集群解决单机Redis存在的问题
11-17
分布式缓存-基于Redis集群解决单机Redis存在的问题。分布式缓存-基于Redis集群解决单机Redis存在的问题。分布式缓存-基于Redis集群解决单机Redis存在的问题。分布式缓存-基于Redis集群解决单机Redis存在的问题。...
Redis 总结
sr0226的博客
07-06 923
一、redis中的数据结构： 1、redis中的key： （1）、redis中key必须是唯一的 （2）、key的操作：https://www.runoob.com/redis/redis-keys.html 2、字符串类型（strings）： （1）、注意：key不要太长，也不要太短，最好不要超过1024字节。 （2）、示例： set是设置key/value，get是获取key...
使用 Redis 实现生成分布式全局唯一ID（使用SpringBoot环境实现）
kerwin的博客
11-10 7357
使用 Redis 实现生成分布式全局唯一ID（使用SpringBoot环境实现）
sprinboot主键自增_SpringBoot使用Redis按照日历生成自增编号
weixin_39556702的博客
12-24 778
目标：在系统中按日历生成编号，如 202003070001刚开始，我想的是使用MySQL存起来就可以了，如果使用MySQL的话会需要以下步骤：(1)判断数据库中今天是否有编号(2)如果没有，那么使用0001，如果有，那么从查询到的今天最大的一位数字+1(3)然后再存入数据库这样一来二区，查询就两次，然后截取字符串，然后+1等等操作，感觉哪里不爽，而且直接对数据库频繁读、写，还会存在数据库锁的获取等...
redis 来生成全局唯一主键
dickzhu的专栏
06-12 1628
[quote] https://blog.csdn.net/UnknownZYB/article/details/78334250 [/quote]
使用redis生成全局唯一id
热门推荐
UnknownZYB的博客
10-24 1万+
生成唯一客户编码需求：1.id生成有一定规则，可识别           2.全局保持唯一，支持分布式思路：1.年月日+每日自增数             2.每天23:59:59秒把自增数清0 优势：1.通过年月日可以看出用户注册时间           2.通过自增数可以看出每日注册量使用redis原因：redis本身单线程，不会出现并发问题redis自身有过期策略使用RedisAtomicL...
spring boot定制Jackson ObjectMapper，为什么不生效
weixin_30695195的博客
03-19 3226
先说结论： 项目中定制了spring 的redisTemplate，而这个template没有使用我自定义的Jackson ObjectMapper。所以不生效。 下面是详细过程： 起因是spring boot项目加入了shiro，我打算使用redis去存储shiro的会话，方便以后横向扩展。 参考了网上的实现后，决定通过扩展org.apache.shiro.session.mgt....
redis获取自增长序号
ntotl的博客
08-28 4903
Jedis jedis = new Jedis(192.168.1.174,6379);//redis服务器的ip和端口  ong accountId = jedis.incrBy(key, 1); //返回加1后的结果
java+redis+lua生成自动增长的ID序列号
06-09
可以使用Redis的原子操作INCR和Lua脚本来实现自动增长的ID序列号。 首先，在Java中连接Redis并执行Lua脚本： ```java Jedis jedis = new Jedis("localhost"); String script = "return redis.call('INCR', KEYS[1]...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值