redission -- 配置

超、凢脫俗 2022-09-15 05:38 188阅读 0赞

spring.redis.host= ${redis.host}
    					spring.redis.port= 6379
    					spring.redis.password=${redis.password}
    					spring.redis.jedis.pool.max-active=30
    					spring.redis.jedis.pool.max-wait=3000
    					spring.redis.jedis.pool.max-idle=20
    					spring.redis.jedis.pool.min-idle=2
    					spring.redis.timeout=3000

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

import com.alibaba.genie.aftersale.common.util.LockUtil;
    import com.alibaba.genie.aftersale.common.util.redisson.RedissonLocker;
    import org.redisson.Redisson;
    import org.redisson.api.RedissonClient;
    import org.redisson.config.Config;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import java.io.IOException;
    
    
    /** * 〈功能描述〉<br> * ----- : 备用 * * @date 2021/10/9 11:55 */
    @Configuration
    public class RedissonConfig { 
    
        @Value("${spring.redis.host}")
        private String host;
        @Value("${spring.redis.port}")
        private String port;
        @Value("${spring.redis.password}")
        private String password;
    
        /** * RedissonClient,单机模式 */
        @Bean(destroyMethod = "shutdown")
        public RedissonClient redisson() { 
            Config config = new Config();
            config.useSingleServer().setAddress("redis://" + host + ":" + port).setPassword(password);
            return Redisson.create(config);
        }
    
        @Bean
        public RedissonLocker redissonLocker(RedissonClient redissonClient) { 
            RedissonLocker locker = new RedissonLocker(redissonClient);
            //设置LockUtil的锁处理对象
            LockUtil.setLocker(locker);
            return locker;
        }
    }

工具类

import java.util.concurrent.TimeUnit;
    
    /** * 〈功能描述〉<br> * ----- : * * @date 2021/10/9 11:56 */
    public interface Locker { 
    
        /** * 获取锁，如果锁不可用，则当前线程处于休眠状态，直到获得锁为止。 * * @param lockKey */
        void lock(String lockKey);
    
        /** * 释放锁 * * @param lockKey */
        void unlock(String lockKey);
    
        /** * 获取锁,如果锁不可用，则当前线程处于休眠状态，直到获得锁为止。如果获取到锁后，执行结束后解锁或达到超时时间后会自动释放锁 * * @param lockKey * @param timeout */
        void lock(String lockKey, int timeout);
    
        /** * 获取锁,如果锁不可用，则当前线程处于休眠状态，直到获得锁为止。如果获取到锁后，执行结束后解锁或达到超时时间后会自动释放锁 * * @param lockKey * @param unit * @param timeout */
        void lock(String lockKey, TimeUnit unit, int timeout);
    
        /** * 尝试获取锁，获取到立即返回true,未获取到立即返回false * * @param lockKey * @return */
        boolean tryLock(String lockKey);
    
        /** * 尝试获取锁，在等待时间内获取到锁则返回true,否则返回false,如果获取到锁，则要么执行完后程序释放锁， * 要么在给定的超时时间leaseTime后释放锁 * * @param lockKey * @param waitTime * @param leaseTime * @param unit * @return */
        boolean tryLock(String lockKey, long waitTime, long leaseTime, TimeUnit unit)
                throws InterruptedException;
    
        /** * 锁是否被任意一个线程锁持有 * * @param lockKey * @return */
        boolean isLocked(String lockKey);
    }

import java.util.concurrent.TimeUnit;
    
    /** * 〈功能描述〉<br> * ----- : * * @date 2021/10/9 11:53 */
    @Data
    public class RedissonLocker implements Locker { 
    
        private RedissonClient redissonClient;
    
        public RedissonLocker(RedissonClient redissonClient) { 
            super();
            this.redissonClient = redissonClient;
        }
    
        @Override
        public void lock(String lockKey) { 
            RLock lock = redissonClient.getLock(lockKey);
            lock.lock();
    
        }
    
        @Override
        public void unlock(String lockKey) { 
            RLock lock = redissonClient.getLock(lockKey);
            lock.unlock();
        }
    
        @Override
        public void lock(String lockKey, int leaseTime) { 
            RLock lock = redissonClient.getLock(lockKey);
            lock.lock(leaseTime, TimeUnit.SECONDS);
        }
    
        @Override
        public void lock(String lockKey, TimeUnit unit, int timeout) { 
            RLock lock = redissonClient.getLock(lockKey);
            lock.lock(timeout, unit);
        }
    
    
        @Override
        public boolean tryLock(String lockKey) { 
            RLock lock = redissonClient.getLock(lockKey);
            return lock.tryLock();
        }
    
        @Override
        public boolean tryLock(String lockKey, long waitTime, long leaseTime,
                               TimeUnit unit) throws InterruptedException { 
            RLock lock = redissonClient.getLock(lockKey);
            return lock.tryLock(waitTime, leaseTime, unit);
        }
    
        @Override
        public boolean isLocked(String lockKey) { 
            RLock lock = redissonClient.getLock(lockKey);
            return lock.isLocked();
        }

package com.alibaba.genie.aftersale.common.util;
    
    import com.alibaba.genie.aftersale.biz.repository.UserRepository;
    import com.alibaba.genie.aftersale.dal.model.UserDO;
    import org.apache.commons.lang3.StringUtils;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.support.atomic.RedisAtomicLong;
    import org.springframework.stereotype.Component;
    
    import java.util.Objects;
    import java.util.concurrent.TimeUnit;
    
    /** * 〈功能描述〉<br> * ----- : * * @date 2021/3/16 13:36 */
    
    @Component
    public class RedisUtil { 
    
        @Autowired
        private RedisTemplate<String, Object> redisTemplate;
    
        @Autowired
        UserRepository userRepository;
    
        /** * 判断key 是否存在，不存在创建key 自增，存在key 自增 * * @param key * @return */
        public Long incrementChecker(String key) { 
            // 判断key是否存在
            if (!hasKey(key)) { 
                set(key, 0);
            }
            return increment(key);
        }
    
    
        /** * 普通缓存放入 * * @param key 键 * @param value 值 * @return true成功 false失败 */
        public boolean set(String key, Object value) { 
            try { 
                redisTemplate.opsForValue().set(key, value);
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
    
        }
    
        /** * 普通缓存获取 * * @param key 键 * @return */
        public Object get(String key) { 
            return redisTemplate.opsForValue().get(key);
        }
    
        /** * 判断key是否存在 * * @param key 键 * @return true 存在 false不存在 */
        public boolean hasKey(String key) { 
            try { 
                return redisTemplate.hasKey(key);
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
    
        /** * 根据key获取自增key的redis值 * * @param key * @return */
        public Long getIncr(String key) { 
            RedisAtomicLong entityIdCounter = new RedisAtomicLong(key, Objects.requireNonNull(redisTemplate.getConnectionFactory()));
            return entityIdCounter.getAndIncrement();
        }
    
        /** * 普通缓存放入并设置时间 * * @param key 键 * @param value 值 * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期 * @return true成功 false 失败 */
        public boolean set(String key, Object value, long time) { 
            try { 
                if (time > 0) { 
                    redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
                } else { 
                    set(key, value);
                }
                return true;
            } catch (Exception e) { 
                e.printStackTrace();
                return false;
            }
        }
    
        /** * 自增 * * @param key * @return 自增后的值 */
        public Long increment(String key) { 
            return this.redisTemplate.opsForValue().increment(key);
        }
    
    
        /** * 自增 num * * @param key * @return 自增后的值 */
        public Long increment(String key, long num) { 
            return this.redisTemplate.opsForValue().increment(key, num);
        }
    
    
        /** * 获取不可变 常量工号 真实姓名 * * * @param workId * @return */
        public String getNick(String workId) { 
            if (get(workId) == null) { 
                UserDO userInfoByWorkId = userRepository.getUserInfoByWorkId(workId);
                if (userInfoByWorkId != null && StringUtils.isNotBlank(userInfoByWorkId.getNickName())) { 
                    set(workId, userInfoByWorkId.getNickName());
                    return userInfoByWorkId.getNickName();
                }
    
            }
    
            return (String) get(workId);
        }
    }

try { 
                 LockUtil.lock("createLock", TimeUnit.SECONDS, 5);
    
            } catch (Exception e) { 
                e.printStackTrace();
            } finally { 
                LockUtil.unlock("createByCooperateLock");
            }