RedissonDistributedLock(redis分布式锁工具类,笔记)
其他
2021-03-30 10:55:02
阅读次数: 0
redisson分布式锁, 支持全局与局部锁
-
RedissonDistributedLock
package com.llb.cloudyoung.tool.lock;
import com.llb.cloudyoung.tool.redis.RedissonConfig;
import com.llb.cloudyoung.tool.utils.DateUtil;
import com.llb.cloudyoung.tool.utils.LogUtil;
import org.redisson.api.RLock;
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.Configuration;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;
@Configuration
public class RedissonDistributedLock {
private static final Logger logger = LoggerFactory.getLogger(RedissonDistributedLock.class);
@Autowired
private RedissonConfig redissonConfig;
private int defaultLockWaitTime = 5;
private int defaultLockLeaseTime = 10;
public RedissonClient getRedisson() {
return redissonConfig.getRedissonInstance();
}
public RLock getLock(String name) {
return getRedisson().getLock(name);
}
public <T> T locked(Supplier<T> supplier, String key, int lockWaitTime, int lockLeaseTime) throws Exception {
lockWaitTime = lockWaitTime <= 0 ? defaultLockWaitTime : lockWaitTime;
lockLeaseTime = lockLeaseTime <= 0 ? defaultLockLeaseTime : lockLeaseTime;
RedissonClient redisson = this.getRedisson();
RLock lock = redisson.getLock(key);
boolean locked = false;
try {
locked = lock.tryLock(lockWaitTime, lockLeaseTime, TimeUnit.SECONDS);
if (!locked) {
LogUtil.info(logger, "分布式锁等待超时! 等待时长:{0},当前时间为:{1}", defaultLockWaitTime, DateUtil.getNow());
throw new RuntimeException("获取分布式锁失败");
}
return supplier.get();
} catch (Exception e) {
LogUtil.error(logger, e, "lock error 当前时间为:{0}", DateUtil.getNow());
throw e;
} finally {
if (locked) {
lock.unlock();
}
}
}
public <T> T locked(Supplier<T> supplier, String key) throws Exception {
return locked(supplier, key, defaultLockWaitTime, defaultLockLeaseTime);
}
}
-
RedissonConfig
package com.llb.cloudyoung.tool.redis;
import com.llb.cloudyoung.tool.enums.RedisArchModelEnum;
import org.apache.commons.lang.StringUtils;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.client.codec.Codec;
import org.redisson.config.Config;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import javax.annotation.Resource;
@Configuration
public class RedissonConfig implements InitializingBean {
private final Config config = new Config();
private RedissonClient redisson;
@Value("${spring.redis.model:sentinel}")
private String model;
@Resource
private RedissonProperties redissonProperties;
private int idleConnectionTimeout = 10000;
private int connectTimeout = 10000;
private int connectionPoolSize = 128;
private int slaveConnectionMinimumIdleSize = 20;
private int slaveConnectionPoolSize = 128;
private int masterConnectionMinimumIdleSize = 20;
private int masterConnectionPoolSize = 128;
private int scanInterval = 100;
private Codec codec;
public RedissonConfig() {
}
public RedissonConfig(RedissonProperties redissonProperties) {
this.redissonProperties = redissonProperties;
}
@Override
public void afterPropertiesSet() throws Exception {
init();
}
public void init() {
if (StringUtils.isBlank(model)) {
throw new IllegalArgumentException("RedissonConfig init method params with:[model] can not be empty......!");
}
if (RedisArchModelEnum.SINGLE.getModel().equals(model)) {
this.initSingleRedissonClient();
} else if (RedisArchModelEnum.SENTINEL.getModel().equals(model)) {
this.initSentinelRedissonClient();
} else if (RedisArchModelEnum.CLUSTER.getModel().equals(model)) {
this.initClusterRedissonClient();
} else {
throw new IllegalArgumentException("RedissonConfig init method params with:[model] invalid......");
}
}
private void initSingleRedissonClient() {
if (StringUtils.isBlank(redissonProperties.getUrl())) {
throw new IllegalArgumentException("redis install mode choice single, must be set singleNodes params......!");
}
config.setCodec(this.getCodec());
config.useSingleServer()
.setPassword(StringUtils.isNotBlank(redissonProperties.getPassword()) ? redissonProperties.getPassword() : null)
.setAddress(redissonProperties.getUrl())
.setDatabase(redissonProperties.getDatabase())
.setIdleConnectionTimeout(idleConnectionTimeout)
.setConnectTimeout(connectTimeout)
.setConnectionPoolSize(connectionPoolSize);
redisson = Redisson.create(config);
}
private void initSentinelRedissonClient() {
if (null == redissonProperties.getSentinel()) {
throw new IllegalArgumentException("redis install mode choice sentinel, must be set sentinelAddress params......!");
}
if (StringUtils.isBlank(redissonProperties.getSentinel().getMaster())) {
throw new IllegalArgumentException("redis install mode choice sentinel, must be set masterName params......!");
}
config.setCodec(this.getCodec());
config.useSentinelServers()
.setMasterName(redissonProperties.getSentinel().getMaster())
.setPassword(StringUtils.isNotBlank(redissonProperties.getPassword()) ? redissonProperties.getPassword() : null)
.setDatabase(redissonProperties.getDatabase())
.setSlaveConnectionMinimumIdleSize(slaveConnectionMinimumIdleSize)
.setSlaveConnectionPoolSize(slaveConnectionPoolSize)
.setMasterConnectionMinimumIdleSize(masterConnectionMinimumIdleSize)
.setMasterConnectionPoolSize(masterConnectionPoolSize)
.setIdleConnectionTimeout(idleConnectionTimeout)
.setConnectTimeout(connectTimeout)
.addSentinelAddress(redissonProperties.getSentinel().getNodes().toArray(new String[]{
}));
redisson = Redisson.create(config);
}
private void initClusterRedissonClient() {
if (null == redissonProperties.getCluster()) {
throw new IllegalArgumentException("redis install mode choice cluster, must be set clusterNodes params......!");
}
config.setCodec(this.getCodec());
config.useClusterServers()
.setScanInterval(scanInterval)
.addNodeAddress(redissonProperties.getCluster().getNodes().toArray(new String[]{
}))
.setPassword(redissonProperties.getPassword())
.setSlaveConnectionMinimumIdleSize(slaveConnectionMinimumIdleSize)
.setSlaveConnectionPoolSize(slaveConnectionPoolSize)
.setMasterConnectionMinimumIdleSize(masterConnectionMinimumIdleSize)
.setMasterConnectionPoolSize(masterConnectionPoolSize)
.setIdleConnectionTimeout(idleConnectionTimeout)
.setConnectTimeout(connectTimeout);
redisson = Redisson.create(config);
}
public RedissonClient getRedissonInstance() {
return redisson;
}
public Codec getCodec() {
return codec;
}
public RedissonConfig setCodec(Codec codec) {
this.codec = codec;
return this;
}
public String getModel() {
return model;
}
public void setModel(String model) {
this.model = model;
}
}
SINGLE("single", "SINGLE"),
MASTERSLAVE("ms", "MASTER-SLAVE"),
SENTINEL("sentinel", "SENTINEL"),
CLUSTER("cluster", "CLUSTER");
private String model;
private String desc;
转载自blog.csdn.net/qq_38893133/article/details/108992317