Redisson 的分布式 Map（RMap）高级功能Redisson 的分布式 Map（RMap）是基于 Redis

Redisson 的分布式 Map（RMap）是基于 Redis 实现的分布式键值存储，不仅提供了与 Java ConcurrentHashMap 类似的 API，还扩展了许多适合分布式场景的高级特性。以下是其核心高级功能的详细介绍：

一、数据结构与存储模式

Redisson 的 RMap 支持多种存储模式，通过 MapOptions 配置：

1. 默认模式（哈希存储）

RMap<String, Integer> map = redisson.getMap("myMap");
// 默认使用 Redis 的 Hash 结构存储，适合中小规模数据

2. 扁平模式（KV 存储）

RMap<String, Integer> flatMap = redisson.getMap(
    "flatMap", 
    MapOptions.<String, Integer>defaults()
        .storeMode(StoreMode.VALUE) // 扁平存储
);
// 每个键值对单独存储为 Redis 的 String，适合大对象存储

3. 缓存模式

RMapCache<String, Integer> cacheMap = redisson.getMapCache("cacheMap");
cacheMap.put("key", 100, 10, TimeUnit.MINUTES); // 设置过期时间
// 支持本地缓存 + 远程同步，减少网络调用

二、原子操作与分布式锁

RMap 提供了丰富的原子操作，避免多节点并发修改时的数据不一致问题：

1. 原子性增/减

RMap<String, Integer> map = redisson.getMap("counterMap");
// 原子性递增（等价于 Java 的 AtomicInteger）
map.addAndGet("counter", 1); // 返回递增后的值
map.getAndAdd("counter", 5); // 返回递增前的值

2. 条件性操作

// 仅当键不存在时设置值（原子性）
map.putIfAbsent("newKey", "value");

// 仅当键存在且值匹配时删除（原子性）
map.remove("key", "oldValue");

// 仅当键存在且值匹配时更新（原子性）
map.replace("key", "oldValue", "newValue");

3. 分布式锁保护

RMap<String, Integer> map = redisson.getMap("protectedMap");
RLock lock = map.getLock("key"); // 获取特定键的锁

try {
    lock.lock();
    // 安全地执行复合操作
    Integer value = map.get("key");
    map.put("key", value + 1);
} finally {
    lock.unlock();
}

三、事件监听与订阅

RMap 支持监听键值变化事件，实现分布式系统间的通知机制：

1. 监听键值变更

RMap<String, String> map = redisson.getMap("eventMap");

// 添加事件监听器
map.addListener(new MapAddListener<String, String>() {
    @Override
    public void onMapAdd(String key, String value) {
        System.out.println("新增键值对: " + key + " = " + value);
    }
});

// 监听键的删除事件
map.addListener(new MapRemoveListener<String>() {
    @Override
    public void onMapRemove(String key) {
        System.out.println("删除键: " + key);
    }
});

2. 批量事件监听

// 监听所有类型的事件
int listenerId = map.addListener(new MapListener() {
    @Override
    public <K, V> void onMapAdd(K key, V value) { /* ... */ }
    
    @Override
    public <K> void onMapRemove(K key) { /* ... */ }
    
    @Override
    public <K, V> void onMapUpdate(K key, V value) { /* ... */ }
});

// 移除监听器
map.removeListener(listenerId);

四、本地缓存与读写分离

为减少网络开销，RMap 支持本地缓存（LocalCachedMap），实现读写分离：

1. 配置本地缓存

LocalCachedMapOptions options = LocalCachedMapOptions.defaults()
    .cacheSize(1000)            // 本地缓存最大容量
    .timeToLive(60, TimeUnit.SECONDS)  // 缓存过期时间
    .maxIdle(30, TimeUnit.SECONDS);   // 最大空闲时间

RLocalCachedMap<String, String> cachedMap = redisson.getLocalCachedMap("cachedMap", options);

2. 读写分离机制

读操作：优先从本地缓存读取，无缓存时从 Redis 获取并缓存；
写操作：同步到 Redis，并通过发布订阅通知其他节点清除本地缓存。

五、异步与批量操作

RMap 支持异步 API 和批量操作，提升高并发场景下的性能：

1. 异步操作

RMap<String, String> map = redisson.getMap("asyncMap");

// 异步写入
RFuture<Void> future = map.putAsync("key", "value");
future.thenAccept(v -> System.out.println("写入完成"));

// 异步读取
RFuture<String> getFuture = map.getAsync("key");
getFuture.thenApply(value -> {
    // 处理返回值
    return value.toUpperCase();
});

2. 批量操作

RMap<String, String> map = redisson.getMap("batchMap");

// 批量添加
Map<String, String> batchData = new HashMap<>();
batchData.put("key1", "value1");
batchData.put("key2", "value2");
map.putAll(batchData);

// 批量删除
map.fastRemove("key1", "key2", "key3"); // 快速删除（无返回值，性能更高）

六、分布式锁与事务

RMap 支持与分布式锁、事务结合使用，保证复杂操作的原子性：

1. 锁与 Map 结合

RMap<String, Integer> map = redisson.getMap("lockedMap");
RLock lock = map.getLock("criticalKey"); // 获取特定键的锁

try {
    lock.lock();
    // 复合操作的原子性
    if (map.get("counter") > 0) {
        map.put("counter", map.get("counter") - 1);
    }
} finally {
    lock.unlock();
}

2. 事务操作

RTransaction transaction = redisson.createTransaction(TransactionOptions.defaults());
RMap<String, String> txMap = transaction.getMap("txMap");

try {
    txMap.put("key1", "value1");
    txMap.put("key2", "value2");
    transaction.commit(); // 提交事务
} catch (Exception e) {
    transaction.rollback(); // 回滚事务
}

七、LRU 淘汰与过期策略

RMapCache 支持键值对的自动过期和 LRU（最近最少使用）淘汰：

1. 设置过期时间

RMapCache<String, String> cache = redisson.getMapCache("expirableMap");
// 写入时设置过期时间
cache.put("key1", "value1", 30, TimeUnit.MINUTES); // 30分钟后过期
// 单独设置某个键的过期时间
cache.expire("key2", 10, TimeUnit.SECONDS);

2. LRU 淘汰策略

RMapCache<String, String> lruCache = redisson.getMapCache("lruMap");
// 配置最大容量，超出时按 LRU 淘汰
lruCache.setMaxSize(1000); // 最多存储1000个键值对

八、应用场景

分布式缓存：替代本地缓存，支持多节点共享。
计数器：利用原子操作实现分布式计数（如访问量统计）。
配置中心：监听配置变更事件，实时更新应用配置。
分布式会话：存储用户会话信息，支持集群环境下的会话共享。
任务状态跟踪：记录分布式任务的执行状态和进度。

总结

Redisson 的分布式 Map 不仅提供了基础的键值存储功能，还通过扩展分布式锁、事件监听、本地缓存、异步操作等特性，满足了复杂分布式场景的需求。合理利用这些高级特性，可大幅提升系统的性能、可靠性和可扩展性。