0.在通用的jinyi-common项目里创建一个jinyi-common-redis 子模块
1.在子模块jinyi-common-redis 项目pom.xml中添加相关依赖
<parent>
<groupId>com.jinyi.up</groupId>
<artifactId>jinyi-common</artifactId>
<version>1.0.0</version>
<relativePath>../pom.xml</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>jinyi-common-redis</artifactId>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<redisson.version>3.17.6</redisson.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson-spring-boot-starter</artifactId>
<version>${redisson.version}</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
</dependency>
</dependencies>
2.在condition包下创建RedisCondition类
import org.apache.commons.lang3.StringUtils;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.env.Environment;
import org.springframework.core.env.MutablePropertySources;
import org.springframework.core.env.PropertySource;
import org.springframework.core.env.StandardEnvironment;
import org.springframework.core.type.AnnotatedTypeMetadata;
import java.util.Iterator;
/**
* redis配置是否加载条件类
* @date 2023/1/11 15:02
* @desc
*/
public class RedisCondition implements Condition {
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
Environment environment = context.getEnvironment();
if (environment instanceof StandardEnvironment) {
MutablePropertySources mutablePropertySources = ((StandardEnvironment) environment).getPropertySources();
return matchesRedis(mutablePropertySources);
}
return false;
}
private boolean matchesRedis(MutablePropertySources mutablePropertySources) {
Iterator<PropertySource<?>> iterator = mutablePropertySources.iterator();
for (Iterator<PropertySource<?>> it = iterator; it.hasNext(); ) {
PropertySource propertySource = it.next();
if (StringUtils.isNotBlank((CharSequence) propertySource.getProperty("spring.redis.host")) || StringUtils.isNotBlank((CharSequence) propertySource.getProperty("spring.redis.cluster.nodes[0]"))) {
return true;
}
}
return false;
}
}
3.config包下分别创建RedisConfig和RedissionConfig类
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.jinyi.up.common.redis.condition.RedisCondition;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
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;
/**
* redis 配置
*
* @date 2023/1/1 12:03
* @desc
*/
@Configuration
@Conditional(RedisCondition.class)
public class RedisConfig {
@Bean
@SuppressWarnings("all")
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
template.setConnectionFactory(factory);
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
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;
}
}
import cn.hutool.core.text.StrFormatter;
import cn.hutool.core.util.StrUtil;
import com.jinyi.up.common.redis.condition.RedisCondition;
import com.jinyi.up.common.redis.util.RedisLockUtil;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.ClusterServersConfig;
import org.redisson.config.Config;
import org.redisson.config.SingleServerConfig;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
import javax.annotation.PreDestroy;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* redisson配置
*/
@Configuration
@Conditional(RedisCondition.class)
@EnableConfigurationProperties(RedisProperties.class)
public class RedissionConfig {
/**
* 作为项目的通用组件使用
*
* @param redisProperties
* @return
*/
@Bean
public RedissonClient getRedissonClient(RedisProperties redisProperties) {
Config config = new Config();
if (redisProperties.getCluster() != null) {
List<String> nodes = redisProperties.getCluster().getNodes();
nodes = nodes.stream().map(node -> "redis://" + node).collect(Collectors.toList());
ClusterServersConfig clusterServersConfig = config.useClusterServers().setScanInterval(2000);
clusterServersConfig.addNodeAddress(nodes.toArray(new String[nodes.size()]));
if (StrUtil.isNotEmpty(redisProperties.getPassword()))
clusterServersConfig.setPassword(redisProperties.getPassword());
} else {
SingleServerConfig singleServerConfig = config.useSingleServer();
singleServerConfig.setAddress(StrFormatter.format("redis://{}:{}", redisProperties.getHost(), redisProperties.getPort()));
//指定redis中哪一个db区
singleServerConfig.setDatabase(redisProperties.getDatabase());
if (StrUtil.isNotEmpty(redisProperties.getPassword()))
singleServerConfig.setPassword(redisProperties.getPassword());
}
return Redisson.create(config);
}
@PreDestroy
public void destory() {
RedisLockUtil.destory();
}
}
4.util包下添加RedisUtils 和 RedisLockUtil类
import com.jinyi.up.common.redis.condition.RedisCondition;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Conditional;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import java.time.Duration;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
/**
* @author huangchong
* @date 2023/1/1 12:08
* @desc
*/
@Component
@Conditional(RedisCondition.class)
public class RedisUtils {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
// =============================common============================
/**
* 指定缓存失效时间
*
* @param key 键
* @param time 时间(秒)
* @return
*/
public boolean expire(String key, long time) {
try {
if (time > 0) {
redisTemplate.expire(key, time, TimeUnit.SECONDS);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据key 获取过期时间
*
* @param key 键 不能为null
* @return 时间(秒) 返回0代表为永久有效
*/
public long getExpire(String key) {
return redisTemplate.getExpire(key, TimeUnit.SECONDS);
}
/**
* 判断key是否存在
*
* @param key 键
* @return true 存在 false不存在
*/
public boolean hasKey(String key) {
try {
return redisTemplate.hasKey(key);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除缓存
*
* @param key 可以传一个值 或多个
*/
@SuppressWarnings("unchecked")
public void del(String... key) {
if (key != null && key.length > 0) {
if (key.length == 1) {
redisTemplate.delete(key[0]);
} else {
redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
}
}
}
// ============================简易分布式key========================
/**
* 只有在 key 不存在时设置 key 的值
*
* @param key
* @param value
* @return 之前已经存在返回false, 不存在返回true
*/
public boolean setIfAbsent(String key, String value) {
return redisTemplate.opsForValue().setIfAbsent(key, value);
}
/**
* 只有在 key 不存在时设置 key 的值
*
* @param key
* @param value
* @param seconds
* @return 之前已经存在返回false, 不存在返回true
*/
public boolean setIfAbsent(String key, String value, int seconds) {
try {
return redisTemplate.opsForValue().setIfAbsent(key, value, Duration.ofSeconds(seconds));
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
// ============================String=============================
/**
* 普通缓存获取
*
* @param key 键
* @return 值
*/
public Object get(String key) {
return key == null ? null : redisTemplate.opsForValue().get(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 键
* @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 键
* @param delta 要增加几(大于0)
* @return
*/
public long incr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递增因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, delta);
}
/**
* 递减
*
* @param key 键
* @param delta 要减少几(小于0)
* @return
*/
public long decr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递减因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, -delta);
}
// ================================Map=================================
/**
* HashGet
*
* @param key 键 不能为null
* @param field 项 不能为null
* @return 值
*/
public Object hget(String key, String field) {
return redisTemplate.opsForHash().get(key, field);
}
/**
* 获取hashKey对应的所有键值
*
* @param key 键
* @return 对应的多个键值
*/
public Map<Object, Object> hmget(String key) {
return redisTemplate.opsForHash().entries(key);
}
/**
* HashSet
*
* @param key 键
* @param map 对应多个键值
* @return true 成功 false 失败
*/
public boolean hmset(String key, Map<String, Object> map) {
try {
redisTemplate.opsForHash().putAll(key, map);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* HashSet 并设置时间
*
* @param key 键
* @param map 对应多个键值
* @param time 时间(秒)
* @return true成功 false失败
*/
public boolean hmset(String key, Map<String, Object> map, long time) {
try {
redisTemplate.opsForHash().putAll(key, map);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
*
* @param key 键
* @param field 项
* @param value 值
* @return true 成功 false失败
*/
public boolean hset(String key, String field, Object value) {
try {
redisTemplate.opsForHash().put(key, field, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
*
* @param key 键
* @param field 项
* @param value 值
* @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
* @return true 成功 false失败
*/
public boolean hset(String key, String field, Object value, long time) {
try {
redisTemplate.opsForHash().put(key, field, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除hash表中的值
*
* @param key 键 不能为null
* @param item 项 可以使多个 不能为null
*/
public void hdel(String key, Object... item) {
redisTemplate.opsForHash().delete(key, item);
}
/**
* 判断hash表中是否有该项的值
*
* @param key 键 不能为null
* @param field 项 不能为null
* @return true 存在 false不存在
*/
public boolean hHasKey(String key, String field) {
return redisTemplate.opsForHash().hasKey(key, field);
}
/**
* hash递增 如果不存在,就会创建一个 并把新增后的值返回
*
* @param key 键
* @param field 项
* @param by 要增加几(大于0)
* @return
*/
public double hincr(String key, String field, double by) {
return redisTemplate.opsForHash().increment(key, field, by);
}
/**
* hash递减
*
* @param key 键
* @param field 项
* @param by 要减少记(小于0)
* @return
*/
public double hdecr(String key, String field, double by) {
return redisTemplate.opsForHash().increment(key, field, -by);
}
// ============================set=============================
/**
* 根据key获取Set中的所有值
*
* @param key 键
* @return
*/
public Set<Object> sGet(String key) {
try {
return redisTemplate.opsForSet().members(key);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 根据value从一个set中查询,是否存在
*
* @param key 键
* @param value 值
* @return true 存在 false不存在
*/
public boolean sHasKey(String key, Object value) {
try {
return redisTemplate.opsForSet().isMember(key, value);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将数据放入set缓存
*
* @param key 键
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSet(String key, Object... values) {
try {
return redisTemplate.opsForSet().add(key, values);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 将set数据放入缓存
*
* @param key 键
* @param time 时间(秒)
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSetAndTime(String key, long time, Object... values) {
try {
Long count = redisTemplate.opsForSet().add(key, values);
if (time > 0) {
expire(key, time);
}
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 获取set缓存的长度
*
* @param key 键
* @return
*/
public long sGetSetSize(String key) {
try {
return redisTemplate.opsForSet().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 移除值为value的
*
* @param key 键
* @param values 值 可以是多个
* @return 移除的个数
*/
public long setRemove(String key, Object... values) {
try {
Long count = redisTemplate.opsForSet().remove(key, values);
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
// ===============================list=================================
/**
* 获取list缓存的内容
*
* @param key 键
* @param start 开始
* @param end 结束 0 到 -1代表所有值
* @return
*/
public List<Object> lGet(String key, long start, long end) {
try {
return redisTemplate.opsForList().range(key, start, end);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 获取list缓存的长度
*
* @param key 键
* @return
*/
public long lGetListSize(String key) {
try {
return redisTemplate.opsForList().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 通过索引 获取list中的值
*
* @param key 键
* @param index 索引 index>=0时, 0 表头,1 第二个元素,依次类推;index<0时,-1,表尾,-2倒数第二个元素,依次类推
* @return
*/
public Object lGetIndex(String key, long index) {
try {
return redisTemplate.opsForList().index(key, index);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @return
*/
public boolean lSet(String key, Object value) {
try {
redisTemplate.opsForList().rightPush(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public boolean lSet(String key, Object value, long time) {
try {
redisTemplate.opsForList().rightPush(key, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @return
*/
public boolean lSet(String key, List<Object> value) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public boolean lSet(String key, List<Object> value, long time) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据索引修改list中的某条数据
*
* @param key 键
* @param index 索引
* @param value 值
* @return
*/
public boolean lUpdateIndex(String key, long index, Object value) {
try {
redisTemplate.opsForList().set(key, index, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 移除N个值为value
*
* @param key 键
* @param count 移除多少个
* @param value 值
* @return 移除的个数
*/
public long lRemove(String key, long count, Object value) {
try {
Long remove = redisTemplate.opsForList().remove(key, count, value);
return remove;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
}
import com.jinyi.up.common.base.exception.ServiceException;
import com.jinyi.up.common.base.result.ResultCodeEnum;
import com.jinyi.up.common.redis.condition.RedisCondition;
import org.redisson.api.RLock;
import org.redisson.api.RReadWriteLock;
import org.redisson.api.RedissonClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Conditional;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.util.concurrent.TimeUnit;
/**
* redis分布式锁
* 支持可重入
* 使用步骤:1 、getLock() 获得锁 2、unLock() 释放锁
* 默认锁15秒,如果执行业务可能超过15秒请自行设置
*/
@Component
@Conditional(RedisCondition.class)
public class RedisLockUtil {
@Autowired
RedissonClient redissonClient;
private static RedissonClient t_redissonClient;
static Logger logger = LoggerFactory.getLogger(RedisLockUtil.class);
@PostConstruct
private void init() {
t_redissonClient = redissonClient;
}
/**
* 加锁,执行完请主动unLock释放锁
* 默认锁15秒,如果执行业务可能超过15秒请自行设置
*
* @param lockKey
* @return
*/
public static RLock getLock(String lockKey) {
return getLock(lockKey, 15);
}
/**
* 加锁,执行完请主动unLock释放锁
*
* @param lockKey
* @param leaseTime 自动解锁时间
* @return
*/
public static RLock getLock(String lockKey, long leaseTime) {
RLock rLock = t_redissonClient.getLock(lockKey);
if (rLock != null) {
try {
if (rLock.tryLock(leaseTime, TimeUnit.SECONDS)) {
logger.info("已经获取到了分布式锁,lockKey:{}", lockKey);
return rLock;
}
logger.warn("分布式锁被其他进程占用,还未释放,lockKey:{}", lockKey);
throw new ServiceException(ResultCodeEnum.DISTRIBUTED_LOCK);
} catch (InterruptedException e) {
logger.error("获取分布式锁发生了InterruptedException异常", e);
if (rLock.tryLock()) {
return rLock;
}
logger.warn("获取分布式锁发生了InterruptedException后尝试获得锁不成功");
throw new RuntimeException("无法获得分布式锁");
}
} else {
logger.warn("无法获取rLock对象,lockKey:{}", lockKey);
throw new ServiceException(ResultCodeEnum.DISTRIBUTED_LOCK);
}
}
/**
* 加锁,执行完请主动unLock释放锁
*
* @param lockKey
* @param waitTime 锁等待时间
* @param leaseTime 自动解锁时间
* @return
*/
public static RLock getLock(String lockKey, long waitTime, long leaseTime) {
RLock rLock = t_redissonClient.getLock(lockKey);
if (rLock != null) {
try {
if (rLock.tryLock(waitTime, leaseTime, TimeUnit.SECONDS)) {
return rLock;
}
logger.warn("分布式锁被其他进程占用,还未释放,lockKey:{}", lockKey);
throw new ServiceException(ResultCodeEnum.DISTRIBUTED_LOCK);
} catch (InterruptedException e) {
logger.error("获取分布式锁发生了InterruptedException异常", e);
if (rLock.tryLock()) {
return rLock;
}
logger.warn("获取分布式锁发生了InterruptedException后尝试获得锁不成功");
throw new RuntimeException("无法获得分布式锁");
}
} else {
logger.warn("无法获取rLock对象,lockKey:{}", lockKey);
throw new ServiceException(ResultCodeEnum.DISTRIBUTED_LOCK);
}
}
/**
* 解锁
*
* @param rLock
*/
public static void unLock(RLock rLock) {
if (rLock != null && rLock.isLocked()) {
rLock.unlock();
}
rLock = null;
}
/**
* 获取redisson 读写锁
*
* @param RWLockKey 读写锁key
* @return RReadWriteLock
*/
public static RReadWriteLock getReadWriteLock(String RWLockKey) {
RReadWriteLock readWriteLock = t_redissonClient.getReadWriteLock(RWLockKey);
return readWriteLock;
}
/**
* 获取redisson写锁 ---*执行完请主动unLock释放锁*---
* 默认锁15秒,如果执行业务可能超过15秒请自行设置
*
* @param WLockKey 写锁key
* @return RLock
*/
public static RLock getWriteLock(String WLockKey) {
return getWriteLock(WLockKey, 15);
}
/**
* 获取redisson写锁 ---*执行完请主动unLock释放锁*---
*
* @param WLockKey 写锁key
* @param leaseTime 自动解锁时间
* @return RLock
*/
public static RLock getWriteLock(String WLockKey, long leaseTime) {
RReadWriteLock readWriteLock = t_redissonClient.getReadWriteLock(WLockKey);
RLock rLock = readWriteLock.readLock();
try {
if (rLock.tryLock(leaseTime, TimeUnit.SECONDS)) {
logger.info("获取分布式写锁 success,RLockKey:{}",WLockKey);
return rLock;
}
logger.warn("分布式写锁被其他进程占用,还未释放,WLockKey:{}", WLockKey);
throw new ServiceException(ResultCodeEnum.DISTRIBUTED_LOCK);
} catch (InterruptedException e) {
logger.error("获取分布式写锁发生了InterruptedException异常", e);
if (rLock.tryLock()) {
logger.info("获取分布式写锁 success,RLockKey:{}",WLockKey);
return rLock;
}
logger.error("获取分布式写锁发生了InterruptedException后尝试获得锁不成功");
throw new RuntimeException("无法获得分布式锁");
}
}
/**
* 获取redisson 写锁
*
* @param WLockKey 写锁key
* @param waitTime 锁等待时间
* @param leaseTime 自动解锁时间
* @return
* @return
*/
public static RLock getWriteLock(String WLockKey, long waitTime, long leaseTime) throws InterruptedException {
RReadWriteLock readWriteLock = t_redissonClient.getReadWriteLock(WLockKey);
RLock rLock = readWriteLock.writeLock();
try {
if (rLock.tryLock(waitTime, leaseTime, TimeUnit.SECONDS)) {
logger.info("获取分布式写锁 success,RLockKey:{}",WLockKey);
return rLock;
}
logger.warn("分布式写锁被其他进程占用,还未释放,WLockKey:{}", WLockKey);
throw new ServiceException(ResultCodeEnum.DISTRIBUTED_LOCK);
} catch (InterruptedException e) {
logger.error("获取分布式写锁发生了InterruptedException异常", e);
if (rLock.tryLock()) {
logger.info("获取分布式写锁 success,RLockKey:{}",WLockKey);
return rLock;
}
logger.error("获取分布式写锁发生了InterruptedException后尝试获得锁不成功");
throw new RuntimeException("无法获得分布式锁");
}
}
/**
* 获取redisson写锁
*
* @return
*/
public static RLock getReadLock(String RLockKey) {
logger.info("获取分布式读锁 start,RLockKey:{}",RLockKey);
RReadWriteLock readWriteLock = t_redissonClient.getReadWriteLock(RLockKey);
RLock rLock = readWriteLock.readLock();
rLock.lock();
logger.info("获取分布式读锁 success,RLockKey:{}",RLockKey);
return rLock;
}
/**
* 关闭RedissonClient
*/
public static void destory() {
if (t_redissonClient != null) {
t_redissonClient.shutdown();
}
}
}
注:util 中有些通用的异常码和自定义的异常类,小伙伴们自行注释和修改即可
6.resources 包里添加 META-INF文件夹,文件夹下创建spring.factories
里面配置上config 和util包中需要引入容器的类的全路径
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.jinyi.up.common.redis.config.RedisConfig,\
com.jinyi.up.common.redis.config.RedissionConfig,\
com.jinyi.up.common.redis.util.RedisUtils,\
com.jinyi.up.common.redis.util.RedisLockUtil
7.例如user项目里需要引入jinyi-common-redis。只需要在user项目pom.xml里加入jinyi-common-redis项目的依赖和yml配置上redis相关配置即可
<dependency>
<groupId>com.jinyi.up</groupId>
<artifactId>jinyi-common-redis</artifactId>
<version>${jinyi-up.version}</version>
</dependency>
spring:
redis:
database: 0 # Redis服务器数据库
host: localhost # Redis服务器地址
port: 6379 # Redis服务器连接端口
password: 123456 # Redis服务器连接密码(默认为空)
timeout: 6000ms # 连接超时时间(毫秒)
8.使用
@Autowired
RedisUtils redisUtils;
public Object biz() {
//获得分布式锁
RLock r = RedisLockUtil.getLock("index");
try{
//操作缓存
Object value=redisUtils.get(key);
业务代码
} finally{
r.unlock();
}
return "biz ok";
}