Redis分布式锁加时效和不加时效两种方案的最全代码实现

迈不过友情╰ 2023-10-08 11:57 2阅读 0赞

> 锁住3秒：

@Autowired
    private RedisTemplate redisTemplate;
    
    String withdrawals_apply_key = WITHDRAWALS_REDIS_KEY+driver.getId();
    boolean flag = redisTemplate.opsForValue().setIfAbsent(withdrawals_apply_key,WITHDRAWALS_LOCK);
    log.info("任务是否获取到锁:" + flag);
    if (flag) {
        redisTemplate.expire(withdrawals_apply_key,3,TimeUnit.SECONDS);
        //要锁住的代码
        。。。。。。
    }else{
        log.info("任务没有获取到锁，不执行!");
        return;
    }

> 锁不设置时效：

@Autowired
    private RedisTemplate redisTemplate;
    
    boolean flag = false;
    try{
        flag = redisTemplate.opsForValue().setIfAbsent(REDIS_KEY, LOCK);
        log.info("是否获取到锁:" + flag);
        if (flag){
            //要锁住的代码
            。。。。。。
        }else {
            log.info("没有获取到锁，不执行定时任务!");
            return;
        }
    }finally {
        if (flag) {
            redisTemplate.delete(REDIS_KEY);
            log.info("任务结束，释放锁!");
        } else {
            log.info("没有获取到锁，无需释放锁!");
        }
    }

> redis的配置类（springboot）：

import com.fengyuncx.common.utils.json.FastJsonRedisSerializer;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
    import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
    import org.springframework.boot.context.properties.EnableConfigurationProperties;
    import org.springframework.cache.annotation.EnableCaching;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.Primary;
    import org.springframework.data.redis.cache.RedisCacheConfiguration;
    import org.springframework.data.redis.cache.RedisCacheManager;
    import org.springframework.data.redis.cache.RedisCacheWriter;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.connection.RedisPassword;
    import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
    import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
    import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
    import org.springframework.data.redis.core.*;
    import org.springframework.data.redis.serializer.RedisSerializationContext;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    import redis.clients.jedis.JedisPoolConfig;
    
    import java.time.Duration;
    
    @Configuration
    @EnableCaching
    @ConditionalOnClass(RedisOperations.class)
    @EnableConfigurationProperties(RedisProperties.class)
    public class RedisConfig {
    
    
        @Value("${spring.driverRedis.host}")
        private String host;
    
        @Value("${spring.driverRedis.port}")
        private int port;
    
        @Value("${spring.driverRedis.password}")
        private String password;
    
        @Value("${spring.driverRedis.maxTotal}")
        private Integer maxTotal;
    
        @Value("${spring.driverRedis.maxIdle}")
        private Integer maxIdle;
    
        @Value("${spring.driverRedis.maxWaitMillis}")
        private Integer maxWaitMillis;
    
        @Value("${spring.driverRedis.timeout}")
        private int timeout;
    
        @Value("${spring.driverRedis.database}")
        private int database;
    
    
        @Primary
        @Bean
        public RedisConnectionFactory cacheBusinessRedisConnectionFactory() {
    
            JedisPoolConfig poolConfig = new JedisPoolConfig();
            poolConfig.setMaxTotal(maxTotal);
            poolConfig.setMaxIdle(maxIdle);
            poolConfig.setMaxWaitMillis(maxWaitMillis);
            poolConfig.setTestOnBorrow(true);
            poolConfig.setTestOnReturn(false);
            poolConfig.setTestWhileIdle(true);
            JedisClientConfiguration clientConfig = JedisClientConfiguration.builder()
                    .usePooling().poolConfig(poolConfig).and().readTimeout(Duration.ofMillis(timeout)).build();
    
            // 单点redis
            RedisStandaloneConfiguration redisConfig = new RedisStandaloneConfiguration();
            // 哨兵redis
            // RedisSentinelConfiguration redisConfig = new RedisSentinelConfiguration();
            // 集群redis
            // RedisClusterConfiguration redisConfig = new RedisClusterConfiguration();
            redisConfig.setHostName(host);
            redisConfig.setPassword(RedisPassword.of(password));
            redisConfig.setPort(port);
            redisConfig.setDatabase(database);
    
            return new JedisConnectionFactory(redisConfig, clientConfig);
    
        }
    
        /**
         * 管理缓存 springboot2
         *
         * @param redisTemplate
         * @return
         */
        @Bean
        public RedisCacheManager redisCacheManager(RedisTemplate redisTemplate) {
    
            //初始化一个RedisCacheWriter
            RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisTemplate.getConnectionFactory());
    
            RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                    .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(redisTemplate.getValueSerializer()));//设置序列化
            //设置默认超过期时间是30秒
            redisCacheConfiguration.entryTtl(Duration.ofSeconds(30));
            //初始化RedisCacheManager
            RedisCacheManager cacheManager = new RedisCacheManager(redisCacheWriter, redisCacheConfiguration);
            return cacheManager;
        }
    
        @Bean
        public RedisTemplate<String, Object> redisTemplate() {
            RedisTemplate<String, Object> template = new RedisTemplate<>();
    
    //        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
    //        template.setValueSerializer(jackson2JsonRedisSerializer);
    //        template.setHashValueSerializer(jackson2JsonRedisSerializer);
    
    
            //使用fastjson序列化
            FastJsonRedisSerializer fastJsonRedisSerializer = new FastJsonRedisSerializer(Object.class);
            // value值的序列化采用fastJsonRedisSerializer
            template.setValueSerializer(fastJsonRedisSerializer);
            template.setHashValueSerializer(fastJsonRedisSerializer);
            // key的序列化采用StringRedisSerializer
            template.setKeySerializer(new StringRedisSerializer());
            template.setHashKeySerializer(new StringRedisSerializer());
    //
            template.setConnectionFactory(cacheBusinessRedisConnectionFactory());
            return template;
        }
    
    
        /**
         * 对hash类型的数据操作
         *
         * @param redisTemplate
         * @return
         */
        @Bean
        public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
            return redisTemplate.opsForHash();
        }
    
        /**
         * 对redis字符串类型数据操作
         *
         * @param redisTemplate
         * @return
         */
        @Bean
        public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
            return redisTemplate.opsForValue();
        }
    
        /**
         * 对链表类型的数据操作
         *
         * @param redisTemplate
         * @return
         */
        @Bean
        public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
            return redisTemplate.opsForList();
        }
    
        /**
         * 对无序集合类型的数据操作
         *
         * @param redisTemplate
         * @return
         */
        @Bean
        public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
            return redisTemplate.opsForSet();
        }
    
        /**
         * 对有序集合类型的数据操作
         *
         * @param redisTemplate
         * @return
         */
        @Bean
        public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
            return redisTemplate.opsForZSet();
        }
    }

> application.yml配置内容：

spring:
      driverRedis:
        host: 192.168.101.100
        port: 6379
        password: 123456
        maxIdle: 300
        maxTotal: 600
        maxWaitMillis: 1000
        timeout: 3000
        database: 4
      dictRedis:
        host: 192.168.101.100
        port: 6379
        password: 123456
        maxIdle: 300
        maxTotal: 600
        maxWaitMillis: 1000
        timeout: 3000
        database: 0