#### 前言：为什么选择 Redisson？
作为 Redis 的 Java 客户端，Redisson 不仅仅是一个简单的连接工具，它是一个完整的实时数据平台，专为 Java 开发者设计。它将 Redis 的高性能键值存储与 Java 的标准集合、锁和同步器无缝整合，让你无需学习 Redis 的 400+ 命令，就能像使用本地 Java 对象一样操作分布式数据。这大大降低了学习曲线，尤其适合构建微服务、缓存系统或分布式锁的场景。
Redisson 支持同步/异步/Reactive/RxJava API，兼容 Redis 2.8+ 和 JDK 8+，并扩展了 50+ 种分布式 Java 对象（如 Map、List、Lock、Semaphore）。它基于 Netty 框架实现异步事件驱动，确保高吞吐量和低延迟。根据官方文档和社区反馈，Redisson 在分布式环境中表现优异，能处理数百万 QPS 的负载，同时提供客户端缓存和本地缓存以优化性能。
本教程由浅入深，结合代码示例和实际场景，帮助你从安装起步，到高级集成。假设你有基本的 Java 和 Maven 知识。我们将使用 Redis 单节点（localhost:6379）作为示例环境，生产中可扩展到集群。
---
### 第一章：入门基础 - 安装与简单连接
#### 1.1 环境准备
- **安装 Redis**：下载 Redis 7.0+（推荐最新版，支持 Valkey 兼容）。在 Ubuntu 上运行：
```
sudo apt update
sudo apt install redis-server
sudo systemctl start redis-server
```
验证：`redis-cli ping` 应返回 `PONG`。
- **Java 环境**：JDK 8+，Maven 3.6+。
- **Redisson 依赖**：在 `pom.xml` 中添加（最新版 3.25.0+，检查 Maven Central）：
```xml
org.redisson
redisson
3.25.3
```
对于 Spring Boot 项目，可用 Starter：
```xml
org.redisson
redisson-spring-boot-starter
3.25.3
```
#### 1.2 基本配置与连接
Redisson 通过 `Config` 对象配置，支持单节点、哨兵、主从、集群模式。这里从单节点起步。
创建配置类 `RedissonConfig.java`：
```java
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
public class RedissonConfig {
public static RedissonClient createClient() {
Config config = new Config();
config.useSingleServer()
.setAddress("redis://127.0.0.1:6379") // Redis 地址，支持 rediss:// (SSL)
.setConnectionPoolSize(64) // 连接池大小，生产调大
.setConnectionMinimumIdleSize(10) // 最小空闲连接
.setRetryAttempts(3) // 重试次数
.setTimeout(5000); // 超时 (ms)
return Redisson.create(config);
}
}
```
- **解释**：`useSingleServer()` 用于单节点；`setAddress` 支持密码如 `redis://:password@host:port`。更多选项见官方文档。
#### 1.3 第一个示例：存储与读取简单对象
使用 `RBucket` 存储任意对象（最大 512MB），类似于 Java 的变量。
`SimpleExample.java`：
```java
import org.redisson.api.RBucket;
import org.redisson.api.RedissonClient;
public class SimpleExample {
public static void main(String[] args) {
RedissonClient redisson = RedissonConfig.createClient();
// 存储对象
RBucket bucket = redisson.getBucket("myKey");
bucket.set("Hello, Redisson!");
// 读取对象
String value = bucket.get();
System.out.println("Value: " + value); // 输出: Hello, Redisson!
redisson.shutdown(); // 关闭客户端
}
}
```
- **运行**：编译运行，检查 Redis：`redis-cli get myKey` 显示序列化值。
- **关键点**：Redisson 自动序列化（默认 JSON），支持自定义 Codec 如 Kryo 以提升性能。
这一步让你快速感受到 Redisson 的便利：无需手动 `SET/GET`，直接用 Java 对象。
---
### 第二章：核心数据结构 - 分布式集合操作
Redisson 提供 Java 标准接口的分布式实现，如 `RMap`（Map）、`RList`（List）等。这些对象线程安全，支持并发访问。
#### 2.1 分布式 Map：RMap 和 RMapCache
`RMap` 是 `ConcurrentMap` 的 Redis 实现，支持原子操作；`RMapCache` 添加 TTL 过期。
示例 `MapExample.java`（基于官方示例）：
```java
import org.redisson.api.RMap;
import org.redisson.api.RMapCache;
import org.redisson.api.RedissonClient;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
public class MapExample {
public static void main(String[] args) {
RedissonClient redisson = RedissonConfig.createClient();
// 基本 RMap
RMap map = redisson.getMap("myMap");
map.put("a", 1);
map.put("b", 2);
map.put("c", 3);
System.out.println("Contains 'a': " + map.containsKey("a")); // true
System.out.println("Value of 'c': " + map.get("c")); // 3
map.addAndGet("a", 32); // 原子加法: a=33
System.out.println("Updated 'a': " + map.get("a")); // 33
// 批量操作
Set keys = new HashSet<>();
keys.add("a"); keys.add("b"); keys.add("c");
Map slice = map.getAll(keys);
System.out.println("Slice: " + slice); // {a=33, b=2, c=3}
// 读取所有（避免阻塞）
System.out.println("All keys: " + map.readAllKeySet());
System.out.println("All values: " + map.readAllValues());
// RMapCache with TTL
RMapCache cache = redisson.getMapCache("myCache");
cache.put("key1", "value1", 10, TimeUnit.MINUTES); // 过期时间
cache.fastPut("key2", "value2"); // 无过期
redisson.shutdown();
}
}
```
- **高级用法**：`fastPut` 跳过写锁，提升性能；`valueSize(key)` 获取嵌套对象大小。
- **场景**：用户会话存储，键为用户 ID，值为 Session 对象。
#### 2.2 分布式 List：RList
`RList` 是 `List` 的分布式版，支持排序和原子操作。
`ListExample.java`：
```java
import org.redisson.api.RList;
import org.redisson.api.RedissonClient;
import java.util.Arrays;
import java.util.List;
public class ListExample {
public static void main(String[] args) {
RedissonClient redisson = RedissonConfig.createClient();
RList list = redisson.getList("myList");
list.addAll(Arrays.asList("item1", "item2", "item3"));
System.out.println("Size: " + list.size()); // 3
System.out.println("Get index 1: " + list.get(1)); // item2
list.set(1, "updatedItem2");
list.add(0, "newFirst"); // 插入头部
// 原子操作
list.fastAdd("tailItem"); // 尾部添加
System.out.println("Contains: " + list.contains("updatedItem2")); // true
// 排序（默认自然序）
list.sort();
System.out.println("Sorted: " + list);
redisson.shutdown();
}
}
```
- **扩展**：支持 `RScoredSortedSet` 用于带分数的排序列表，如排行榜。
#### 2.3 其他集合：RSet、RQueue、RDeque
- **RSet**（Set）：无序唯一集合。
```java
RSet set = redisson.getSet("mySet");
set.add("unique1");
set.add("unique1"); // 忽略重复
System.out.println("Size: " + set.size()); // 1
```
- **RQueue**（Queue）：FIFO 队列，用于任务调度。
```java
RQueue queue = redisson.getQueue("myQueue");
queue.add("task1");
String task = queue.poll(); // 取出并移除
```
- **RDeque**（Deque）：双端队列，支持从头尾操作。
```java
RDeque deque = redisson.getDeque("myDeque");
deque.addFirst("head");
deque.addLast("tail");
```
这些集合自动处理分布式一致性，使用 Redis 的 List/Set 等底层结构。
---
### 第三章：分布式锁与同步器 - 确保线程安全
在分布式系统中，锁是核心。Redisson 提供 RedLock（多节点安全锁）和多种同步器。
#### 3.1 基本锁：RLock
`RLock` 是 `Lock` 的分布式实现，支持可重入。
`LockExample.java`：
```java
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import java.util.concurrent.TimeUnit;
public class LockExample {
public static void main(String[] args) throws InterruptedException {
RedissonClient redisson = RedissonConfig.createClient();
RLock lock = redisson.getLock("myLock");
lock.lock(10, TimeUnit.SECONDS); // 阻塞获取，10s 超时
try {
// 关键代码区
System.out.println("Lock acquired, doing critical work...");
Thread.sleep(2000); // 模拟工作
} finally {
lock.unlock(); // 释放
}
// 非阻塞获取
if (lock.tryLock(5, 10, TimeUnit.SECONDS)) { // 5s 等待，10s 持有
try {
System.out.println("Try lock success");
} finally {
lock.unlock();
}
}
redisson.shutdown();
}
}
```
- **Watchdog**：自动续期锁（默认 30s 检查），防止死锁。
- **场景**：库存扣减，确保并发安全。
#### 3.2 高级同步器
- **ReadWriteLock**：读写分离，提升并发。
```java
RReadWriteLock rwLock = redisson.getReadWriteLock("rwLock");
rwLock.readLock().lock(); // 读锁，多线程共享
// 读操作
rwLock.readLock().unlock();
```
- **Semaphore**：信号量，控制资源访问。
```java
RSemaphore semaphore = redisson.getSemaphore("mySemaphore");
semaphore.tryAcquire(5); // 获取 5 个许可
semaphore.release(5); // 释放
```
- **CountDownLatch**：计数器，等待多线程完成。
```java
RCountDownLatch latch = redisson.getCountDownLatch("myLatch");
latch.trySetCount(3);
latch.await(); // 等待计数为 0
```
- **RedLock**：多节点锁（至少 N/2+1 节点同意）。
```java
RRedLock redLock = redisson.getRedLock("lock1", "lock2");
redLock.lock();
```
这些工具符合 `java.util.concurrent` 规范，适用于微服务间协调。
---
### 第四章：高级主题 - 异步、Reactive 与集成
#### 4.1 异步与 Reactive API
Redisson 支持非阻塞操作，提升高并发性能。
- **Async API**：
```java
RFuture future = bucket.getAsync();
future.thenAccept(value -> System.out.println(value));
```
- **Reactive API**（基于 Project Reactor）：
```java
import org.redisson.api.RedissonReactiveClient;
RedissonReactiveClient reactive = redisson.reactive();
reactive.getBucket("myKey").get()
.subscribe(value -> System.out.println(value));
```
- **RxJava**：
```java
import org.redisson.api.RedissonRxClient;
RedissonRxClient rx = redisson.rxJava();
rx.getBucket("myKey").get()
.subscribe(value -> System.out.println(value));
```
- **优势**：在 WebFlux 或高吞吐应用中，避免线程阻塞。
#### 4.2 Spring 集成
Redisson 与 Spring 无缝集成，支持 Cache、Session 等。
在 `application.yml`：
```yaml
spring:
redis:
redisson:
config: classpath:redisson.yaml # 配置文件
```
`redisson.yaml` 示例：
```yaml
clusterServersConfig:
nodeAddresses:
- "redis://127.0.0.1:7001"
- "redis://127.0.0.1:7002"
```
Bean 配置：
```java
@Bean
@Primary
public RedisTemplate redisTemplate(RedissonClient redisson) {
// 自定义模板
}
```
- **Spring Cache**：`@Cacheable` 注解自动用 RMapCache。
```java
@Cacheable(value = "users", key = "#id")
public User getUser(Long id) { ... }
```
- **Spring Session**：分布式 Session 存储。
#### 4.3 其他高级功能
- **本地缓存**：`RLocalCachedMap` 减少网络 IO。
```java
RLocalCachedMap localMap = redisson.getLocalCachedMap("myLocalMap");
```
- **RPC**：远程过程调用。
```java
RRemoteService remoteService = redisson.getRemoteService();
// 注册接口实现，远程调用
```
- **Bloom Filter**：高效去重过滤。
```java
RBloomFilter filter = redisson.getBloomFilter("myFilter");
filter.tryInit(1000, 0.03); // 预期元素数，误判率
filter.add("item1");
System.out.println(filter.contains("item1")); // true
```
- **MapReduce**：分布式计算。
```java
RMapReduce mr = map.mapReduce();
// 定义 Mapper/Reducer
```
#### 4.4 集群与高可用配置
对于生产，切换到集群：
```java
Config config = new Config();
config.useClusterServers()
.addNodeAddress("redis://node1:6379", "redis://node2:6380")
.setScanInterval(2000); // 扫描间隔
```
- **故障转移**：自动重连，支持 Sentinel。
- **性能调优**：连接池大小 512+，启用压缩 Codec。
---
### 第五章：最佳实践、性能优化与故障排除
#### 5.1 最佳实践
- **命名空间**：用前缀如 "app:user:" 避免键冲突。
- **TTL 与 Eviction**：所有对象设置过期时间，防止内存溢出。
- **监控**：集成 Micrometer/Prometheus，监控 QPS、延迟。
- **序列化**：用 Jackson/Kryo 优化大对象。
- **测试**：用 Testcontainers 模拟 Redis 环境。
#### 5.2 性能优化
- **客户端缓存**：`RLocalCachedMap` 命中率 >80% 时，QPS 提升 10x。
- **批量操作**：`map.getAll(keys)` 减少 RTT。
- **Netty 线程**：默认 16 线程，生产调至 CPU*2。
- **基准**：Redisson PRO 版在 10 节点集群下，Lock 获取 <1ms。
#### 5.3 常见问题
- **连接超时**：检查防火墙，增加 `setTimeout(10000)`。
- **锁未释放**：用 `tryLock` + finally。
- **序列化错误**：确保对象可序列化，或自定义 Codec。
- **集群模式**：键哈希均匀分布，避免热点。
---
### 结语：进阶之路
恭喜！你已掌握 Redisson 从基础到高级的全貌。实践是关键：从简单缓存起步，逐步集成到生产系统。探索 GitHub 示例仓库（redisson-examples）获取更多代码。 社区活跃，Stack Overflow 有海量 Q&A。
如果想深入 Valkey 兼容或 PRO 版高级功能，参考官方文档：https://redisson.org/docs/ 。构建下一个分布式杰作吧！
登录后可参与表态