使用nacos配置管理，实现redisson分布式锁
添加依赖
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson-spring-boot-starter</artifactId>
<version>3.16.0</version>
</dependency>
<dependency>
<groupId>com.alibaba.boot</groupId>
<artifactId>nacos-config-spring-boot-starter</artifactId>
<version>0.2.1</version>
</dependency>
启动类配置nacos
@SpringBootApplication
@NacosPropertySource(dataId = "test",groupId = "DEFAULT_GROUP",autoRefreshed = true)
public class SprApplication {
public static void main(String[] args) {
SpringApplication.run(SprApplication.class, args);
}
}
redisson配置
@Bean(name = "redissonClient")
public RedissonClient redissonClient() {
Config config = new Config();
config.setLockWatchdogTimeout(30000);
config.setCodec(new StringCodec());
SingleServerConfig singleServerConfig = config.useSingleServer().setAddress(address);
singleServerConfig.setPassword(this.getPassword());
singleServerConfig.setConnectionPoolSize(connectionPoolSize);
System.out.println(("RedissonClient init success!")+singleServerConfig.getAddress());
RedissonClient redissonClient = Redisson.create(config);
return redissonClient;
}
redis配置
@Bean(name = "redisConnectionFactory")
public RedisConnectionFactory redisConnectionFactory() {
JedisConnectionFactory factory = new JedisConnectionFactory();
factory.setHostName(this.getHost());
factory.setUsePool(true);
factory.setPort(this.getPort());
factory.setTimeout(10000);
factory.setPassword(this.password);
JedisPoolConfig config = (JedisPoolConfig) factory.getPoolConfig();
config.setMaxTotal(10000);
config.setMaxIdle(1000);
return factory;
}
@Bean
public JedisPoolConfig jedisPoolConfig() {
JedisPoolConfig poolConfig = new JedisPoolConfig();
poolConfig.setMaxIdle(100);
poolConfig.setMinIdle(100);
poolConfig.setTestOnCreate(true);
poolConfig.setTestOnBorrow(true);
poolConfig.setTestOnReturn(true);
poolConfig.setTestWhileIdle(true);
long maxWaitMillis = 1000 * 60 * 5;
poolConfig.setMaxWaitMillis(maxWaitMillis);
return poolConfig;
}
@Bean("redisTemplate")
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.setHashKeySerializer(new StringRedisSerializer());
redisTemplate.setHashValueSerializer(new StringRedisSerializer());
redisTemplate.setValueSerializer(new StringRedisSerializer());
redisTemplate.setConnectionFactory(factory);
return redisTemplate;
}
线程池的大小根据自己具体情况确定。
可重入锁实现使用
创建Redisson客户端对象。
使用Redisson客户端对象获取一个可重入锁（ReentrantLock）。
在需要使用分布式锁的代码段中，先调用lock()方法获取锁。
执行业务逻辑。
执行完业务逻辑后，调用unlock()方法释放锁。
如果在获取锁的过程中发生了异常，需要调用unlock()方法来释放锁。
public void myMethod() {
String key = "111";
String lockKey = "lock:" + key;
// 可重入锁
RLock lock = redissonClient.getLock(lockKey);
boolean isLocked = lock.tryLock();
System.out.println(isLocked);
if (isLocked) {
try {
System.out.println("Lock");
} catch (Exception e) {
System.out.println(e);
} finally {
if (lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
}
}
公平锁
Redisson公平锁（FairLock）是一种基于Redis实现的分布式公平锁，它可以保证获取锁的顺序和请求锁的顺序一致，避免“饥饿”现象的发生。
在Redisson中，使用公平锁的方式与可重入锁类似。通过Redisson客户端对象获取公平锁对象，然后调用lock()方法获取锁，在获取锁时，根据请求锁的顺序依次排队等待锁的释放，当锁被释放后，等待时间最长的线程会最先获得锁。
RedissonClient redissonClient = Redisson.create();
RLock fairLock = redissonClient.getFairLock("myFairLock");
// 获取锁
fairLock.lock();
try {
// 执行业务逻辑
} finally {
// 释放锁
fairLock.unlock();
}
读写锁（ReadWriteLock）
是一种用于多线程环境下对共享资源进行读写操作的锁，它可以提高系统的并发性能和可伸缩性，适用于读操作频繁、写操作较少的场景。
在读写锁中，读操作可以并发进行，写操作需要独占锁资源。当有一个线程获取写锁时，其他线程不能获取读锁或写锁，只有该线程释放锁之后，其他线程才能获取锁。读写锁的使用可以有效地避免读写冲突问题，提高系统的并发性能和响应速度。
Redisson也提供了读写锁的实现，可以使用RLock readWriteLock = redissonClient.getReadWriteLock("myReadWriteLock")获取读写锁对象，并使用readLock()方法获取读锁对象、writeLock()方法获取写锁对象，具体示例代码如下
RedissonClient redissonClient = Redisson.create();
RLock readWriteLock = redissonClient.getReadWriteLock("myReadWriteLock");
// 获取读锁
RLock readLock = readWriteLock.readLock();
readLock.lock();
try {
// 读取共享资源的数据
} finally {
readLock.unlock();
}
// 获取写锁
RLock writeLock = readWriteLock.writeLock();
writeLock.lock();
try {
// 修改共享资源的数据
} finally {
writeLock.unlock();
}
限流器（RateLimiter）
是一种用于限制系统流量的工具，它可以控制系统处理请求的速率，避免系统因为过多的请求导致的性能下降或者宕机的问题。常见的限流算法有令牌桶算法和漏桶算法等。
Redisson提供了令牌桶算法的实现，可以使用RTopic.create(redissonClient).getBucket("myBucket").trySetRate(RateType type, long rate, long rateInterval, long rateIntervalUnit)方法创建一个令牌桶，并指定限流速率、令牌桶容量等参数。其中，rate参数表示每秒生成的令牌数量，rateInterval和rateIntervalUnit参数表示生成令牌的时间间隔。
在使用限流器时，需要在处理请求之前先从限流器中获取令牌，如果获取成功，则可以处理请求，否则需要等待一段时间再重试。Redisson的令牌桶限流器的示例代码如下：
RedissonClient redissonClient = Redisson.create();
// 创建一个每秒生成10个令牌的令牌桶
RateLimiter rateLimiter = redissonClient.getRateLimiter("myRateLimiter");
rateLimiter.trySetRate(RateType.OVERALL, 10, 1, TimeUnit.SECONDS);
// 处理请求
while (true) {
// 判断是否能够获取到令牌，获取不到则等待一段时间再重试
if (rateLimiter.tryAcquire()) {
// 处理请求
System.out.println("处理请求");
} else {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
一般来说，被限流器限流的请求应该返回一个提示，告知用户请求被限流了。具体的提示信息可以根据业务需求进行定义，例如可以返回一个HTTP状态码为429的响应，并在响应消息中包含“请求过于频繁，请稍后再试”等提示信息。
对于被限流的请求，除了返回一个提示信息外，还可以根据实际情况选择不同的处理方式。例如可以将被限流的请求放入队列中，等待限流器解除限制后再进行处理；或者将被限流的请求进行缓存，等待一定时间后再进行处理。在实际应用中，需要根据业务需求和系统架构进行选择和调整，以实现最佳的流量控制效果。
