springboot集成Redisson

一，pom依赖

<!-- redisson-->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.5.0</version>
</dependency>

二，yml配置

spring:
  # redis 配置
  redis:
    # 地址
    host: localhost
    # 端口，默认为6379
    port: 6379
    # 数据库索引
    database: 0
    # 密码
    password:
    # 连接超时时间
    timeout: 10s
    lettuce:
      pool:
        # 连接池中的最小空闲连接
        min-idle: 0
        # 连接池中的最大空闲连接
        max-idle: 8
        # 连接池的最大数据库连接数
        max-active: 8
        # #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1ms

三，配置类

redission属性配置类（RedissonProperties）

@Configuration
@ConfigurationProperties(prefix = "spring.redis")
@ConditionalOnProperty("spring.redis.password")
@Setter
@Getter
@Primary
public class RedissonProperties {
    private Duration timeout;

    private String host;

    private String port;

    private String password;

    private int database;

    private int connectionPoolSize = 64;

    private int connectionMinimumIdleSize = 10;

    private int slaveConnectionPoolSize = 250;

    private int masterConnectionPoolSize = 250;

    private String[] sentinelAddresses;

    private String masterName;
}

redission自动装配配置类（RedissonAutoConfig）-- redis单机部署

@Configuration
@ConditionalOnClass(Config.class)
@EnableConfigurationProperties(RedissonProperties.class)
public class RedissonAutoConfig {
    private static final Logger log = LoggerFactory.getLogger(RedissonAutoConfig.class);

    @Autowired
    private RedissonProperties redssionProperties;

    /**
     * 单机模式自动装配
     *
     * @return
     */
    @Bean
    RedissonClient redissonSingle() {
        log.info("init RedissonClient.redissonSingle()...");
        Config config = new Config();
        String host = redssionProperties.getHost();
        String port = redssionProperties.getPort();
        String address = "";
        if (StringUtils.isNotBlank(host) && StringUtils.isNotBlank(port)) {
            address = "redis://" + host + ":" + port;
        }
        SingleServerConfig serverConfig = config.useSingleServer()
                .setAddress(address)
                .setTimeout(Math.toIntExact(redssionProperties.getTimeout().getSeconds()))
                .setConnectionPoolSize(redssionProperties.getConnectionPoolSize())
                .setConnectionMinimumIdleSize(redssionProperties.getConnectionMinimumIdleSize())
                .setDatabase(redssionProperties.getDatabase());

        if (StringUtils.isNotBlank(redssionProperties.getPassword())) {
            serverConfig.setPassword(redssionProperties.getPassword());
        }
        //解决存储乱码问题
        config.setCodec(new JsonJacksonCodec());
        return Redisson.create(config);
    }

}

四，工具类

redission工具类（RedissonUtil）

@Component
public class RedissonUtil {

    @Autowired
    private RedissonClient redissonClient;

    /**
     * 锁住不设置超时时间
     *
     * @param lockKey
     * @return org.redisson.api.RLock
     */
    public RLock lock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock();
        return lock;
    }

    /**
     * leaseTime为加锁时间，单位为秒
     *
     * @param lockKey
     * @param leaseTime
     * @return org.redisson.api.RLock
     */
    public RLock lock(String lockKey, long leaseTime) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(leaseTime, TimeUnit.SECONDS);
        return null;
    }

    /**
     * timeout为加锁时间，时间单位由unit确定
     *
     * @param lockKey
     * @param unit
     * @param timeout
     * @return org.redisson.api.RLock
     */
    public RLock lock(String lockKey, TimeUnit unit, long timeout) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(timeout, unit);
        return lock;
    }

    /**
     * 尝试获取锁（时间属性：秒）
     *
     * @param lockKey
     * @param waitTime
     * @param leaseTime
     */
    public boolean tryLock(String lockKey, long waitTime, long leaseTime) {
        RLock lock = redissonClient.getLock(lockKey);
        try {
            return lock.tryLock(waitTime, leaseTime, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            return false;
        }
    }

    /**
     * 尝试获取锁
     *
     * @param lockKey
     * @param unit
     * @param waitTime
     * @param leaseTime
     */
    public boolean tryLock(String lockKey, TimeUnit unit, long waitTime, long leaseTime) {
        RLock lock = redissonClient.getLock(lockKey);
        try {
            return lock.tryLock(waitTime, leaseTime, unit);
        } catch (InterruptedException e) {
            return false;
        }
    }

    /**
     * 通过lockKey解锁
     *
     * @param lockKey
     */
    public void unlock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.unlock();
    }

    /**
     * 直接通过锁解锁
     */
    public void unlock(RLock lock) {
        lock.unlock();
    }
}

五，使用样例

com.ruoyi.framework.web.service.SysLoginService#getUserInfoByOpenId

String lockKey = String.format(SysUserConstant.INIT_USER_BY_OPEN_ID_LOCK_KEY, openId);
boolean lock = false;
try {
    lock = redissonUtil.tryLock(lockKey, 5, 10);
    if (lock) {
        // ... ... todo something ... ...
    } else {
        throw new RuntimeException("操作频繁，请稍后重试");
    }
} finally {
    if (lock) {
        redissonUtil.unlock(lockKey);
    }
}