跳至主要內容

Springboot 整合 Redisson

ZJX2025年11月10日大约 10 分钟

简介

Redisson 相比传统的 Redis 客户端（如 Jedis 或 Lettuce）具有显著的优势，它提供多种锁机制，是解决分布式系统并发问题的首选方案，也可使用它实现多种分布式服务，如限流器（RateLimiter）、信号量（Semaphore）、布隆过滤器（BloomFilter）等，用于解决复杂的分布式协调问题。

Redisson简化了集群、哨兵等复杂部署模式的配置，以下是 Spring Boot 整合 Redisson 的示例代码，他们可被当做标准模板直接在自己项目中使用：

pom.xml
<!-- 版本管理 -->
<properties>
    <org.redisson.version>3.52.0</org.redisson.version>
</properties>

<!-- 引入 -->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>${org.redisson.version}</version>
</dependency>

分布式锁

Redisson 的分布式锁是被高频使用的功能，它实现了 JUC（java.util.concurrent）中的 Lock 接口，并内置了看门狗（Watchdog） 机制，可自动续期，避免业务执行时间过长导致的锁超时释放问题。

可重入锁

单机应用中使用 JUC 的 ReentrantLock 来实现可重入锁（同一个线程可以多次获取同一个锁对象）；

可重入锁是最经典，使用最广泛的分布式锁，它适用于方法调用链复杂、存在嵌套调用的场景，redissonClient.getLock() 方法天然支持可重入锁，这里提供一个通用模板，使用起来更加优雅：

可重入锁
/**
* @ Description: 基于 Redisson 的通用可重入锁工具类
* 支持嵌套调用、超时控制、异常处理
* @ Author: ZJX
**/
@Component
@RequiredArgsConstructor
public class DistributedReentrantLock {

    private final RedissonClient redissonClient;

    /**
    * 获取锁并执行业务逻辑（自动释放锁）
    *
    * @param lockKey   锁的key
    * @param worker    业务逻辑
    * @param waitTime  等待时间
    * @param leaseTime 持有时间
    * @param unit      时间单位
    * @return 业务执行结果
    */
    public <T> T executeWithLock(String lockKey, Supplier<T> worker,
                                long waitTime, long leaseTime, TimeUnit unit) {
        RLock lock = redissonClient.getLock(lockKey);
        boolean locked = false;
        try {
            // 尝试获取锁
            locked = lock.tryLock(waitTime, leaseTime, unit);
            if (!locked) {
                throw new RuntimeException("获取分布式锁失败，lockKey: " + lockKey);
            }
            // 执行业务逻辑
            return worker.get();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("获取锁时被中断", e);
        } finally {
            if (locked) {
                lock.unlock();
            }
        }
    }

    /**
    * 简化版本 - 默认超时时间
    */
    public <T> T executeWithLock(String lockKey, Supplier<T> worker) {
        return executeWithLock(lockKey, worker, 3, 30, TimeUnit.SECONDS);
    }

    /**
    * 无返回值的锁执行
    */
    public void executeWithLock(String lockKey, Runnable task) {
        executeWithLock(lockKey, () -> {
            task.run();
            return null;
        });
    }
}

读写锁

单机应用中使用 JUC 的 ReentrantReadWriteLock 来实现读写锁（多个线程可以同时读；写操作线程独占，写期间禁止读）；在常规业务开发中，很少需要使用读写锁，因为它依赖锁机制，最终效果是数据的强一致性。

读写锁仅适用于高并发下读多写少的场景，且写操作期间读操作会阻塞。但实际业务中，高频访问的数据会放入缓存，而修改数据更多会涉及到数据库和缓存同步问题，关注点是最终一致性，而不是使用读写锁达到强一致性的效果。可使用 redissonClient.getReadWriteLock() 方法来实现分布式读写锁，了解即可，它很少用到。

接口防重幂等

防重功能可有效防止同一个用户在 限制时间内对同一个业务提交相同的数据，可结合 Redis 实现，这里就不提供代码量了，市面上有不少防重幂等的实现，强烈建议参考此篇文章，非常优秀！

缓存、限流、发布订阅等

声明式缓存

使用 SpringBoot 提供的 @Cacheable 注解实现缓存，详见Redission 缓存。

编程式缓存、限流、发布订阅等

以下工具类包含众多使用 Redisson 客户端操作 Redis 的方法，包含常见功能如 Redis 的 CRUD、缓存、限流、订阅发布、分布式hash、分布式set等方法，可将其直接引入项目中使用。

但是由于这个工具类有 500 多行，直接写在博客里不太美观，下面代码仅截取了一小部分展示，可

。

/**
 * @ Description: redis 工具类
 * @ Author: ZJX
 **/
@NoArgsConstructor(access = AccessLevel.PRIVATE)
@SuppressWarnings(value = {"unchecked", "rawtypes"})
public class RedisUtils {

    private static final RedissonClient CLIENT = SpringUtil.getBean(RedissonClient.class);

    /**
     * 限流
     *
     * @param key          限流key
     * @param rateType     限流类型
     * @param rate         速率
     * @param rateInterval 速率间隔
     * @return -1 表示失败
     */
    public static long rateLimiter(String key, RateType rateType, int rate, int rateInterval) {
        return rateLimiter(key, rateType, rate, rateInterval, 0);
    }

    /**
     * 限流
     *
     * @param key          限流key
     * @param rateType     限流类型
     * @param rate         速率
     * @param rateInterval 速率间隔
     * @param timeout      超时时间
     * @return -1 表示失败
     */
    public static long rateLimiter(String key, RateType rateType, int rate, int rateInterval, int timeout) {
        RRateLimiter rateLimiter = CLIENT.getRateLimiter(key);
        rateLimiter.trySetRate(rateType, rate, Duration.ofSeconds(rateInterval), Duration.ofSeconds(timeout));
        if (rateLimiter.tryAcquire()) {
            return rateLimiter.availablePermits();
        } else {
            return -1L;
        }
    }

    /**
     * 获取客户端实例
     */
    public static RedissonClient getClient() {
        return CLIENT;
    }

    /**
     * 发布通道消息
     *
     * @param channelKey 通道key
     * @param msg        发送数据
     * @param consumer   自定义处理
     */
    public static <T> void publish(String channelKey, T msg, Consumer<T> consumer) {
        RTopic topic = CLIENT.getTopic(channelKey);
        topic.publish(msg);
        consumer.accept(msg);
    }

    /**
     * 发布消息到指定的频道
     *
     * @param channelKey 通道key
     * @param msg        发送数据
     */
    public static <T> void publish(String channelKey, T msg) {
        RTopic topic = CLIENT.getTopic(channelKey);
        topic.publish(msg);
    }

    /**
     * 订阅通道接收消息
     *
     * @param channelKey 通道key
     * @param clazz      消息类型
     * @param consumer   自定义处理
     */
    public static <T> void subscribe(String channelKey, Class<T> clazz, Consumer<T> consumer) {
        RTopic topic = CLIENT.getTopic(channelKey);
        topic.addListener(clazz, (channel, msg) -> consumer.accept(msg));
    }

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key   缓存的键值
     * @param value 缓存的值
     */
    public static <T> void setCacheObject(final String key, final T value) {
        setCacheObject(key, value, false);
    }

    /**
     * 缓存基本的对象，保留当前对象 TTL 有效期
     *
     * @param key       缓存的键值
     * @param value     缓存的值
     * @param isSaveTtl 是否保留TTL有效期(例如: set之前ttl剩余90 set之后还是为90)
     * @since Redis 6.X 以上使用 setAndKeepTTL 兼容 5.X 方案
     */
    public static <T> void setCacheObject(final String key, final T value, final boolean isSaveTtl) {
        RBucket<T> bucket = CLIENT.getBucket(key);
        if (isSaveTtl) {
            try {
                bucket.setAndKeepTTL(value);
            } catch (Exception e) {
                long timeToLive = bucket.remainTimeToLive();
                if (timeToLive == -1) {
                    bucket.set(value);
                } else {
                    bucket.set(value, Duration.ofMillis(timeToLive));
                }
            }
        } else {
            bucket.set(value);
        }
    }

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key      缓存的键值
     * @param value    缓存的值
     * @param duration 时间
     */
    public static <T> void setCacheObject(final String key, final T value, final Duration duration) {
        RBucket<T> bucket = CLIENT.getBucket(key);
        bucket.set(value, duration);
    }

    /**
     * 如果不存在则设置 并返回 true 如果存在则返回 false
     *
     * @param key   缓存的键值
     * @param value 缓存的值
     * @return set成功或失败
     */
    public static <T> boolean setObjectIfAbsent(final String key, final T value, final Duration duration) {
        RBucket<T> bucket = CLIENT.getBucket(key);
        return bucket.setIfAbsent(value, duration);
    }

    /**
     * 如果存在则设置 并返回 true 如果存在则返回 false
     *
     * @param key   缓存的键值
     * @param value 缓存的值
     * @return set成功或失败
     */
    public static <T> boolean setObjectIfExists(final String key, final T value, final Duration duration) {
        RBucket<T> bucket = CLIENT.getBucket(key);
        return bucket.setIfExists(value, duration);
    }
}
最近更新：