• 新闻资讯
  • 玩轉Redis！非常強大的Redisson分散式集合，少寫60%程式碼

玩轉Redis！非常強大的Redisson分散式集合，少寫60%程式碼

1. 簡介

Redisson 是Redis Java 用戶端和即時資料平台。它為使用Redis 提供了更方便、更簡單的方法。 Redisson 物件提供了關注點分離功能，可讓你專注於資料建模和應用邏輯。

在Java中，為我們提供了豐富的集合類，如List、Set、Map等，這些集合類在單機應用或單一JVM進程中是非常強大且有效的工具。然而，在分散式系統下，資料需要在多個JVM進程或節點之間共用和同步。為實現這一目標Redisson提供了許多分散式集合實現，如RList、RSet、RMap等，這些集合類別能夠在多個Redis節點之間無縫地共享資料。透過使用Redisson，開發者可以像使用傳統Java集合類別一樣，在分散式系統中進行資料的增刪改查操作，而無需擔心資料在不同節點之間的同步和一致性問題。

2. 實戰案例

2.1 Map集合

基於Redis 的Java 分散式Map 物件實作了 ConcurrentMap 介面。該對像是完全線程安全的。

  • RMap類別關係
public interface RMap<K, V> extends ConcurrentMap<K, V>, ...{}
  • 1.

接下來所有操作都是基於RedissonClient對象

@Resource
private RedissonClient redisson ;
  • 1.
  • 2.
  • 同步存資料
RMap<String, User> map = redisson.getMap("user-list");
User preValue = map.put("1", new User(2L, "张三2", 22)) ;
User value = map.putIfAbsent("2", new User(2L, "李四", 33));
  • 1.
  • 2.
  • 3.
  • 快速存資料

如果你不需要回傳上一個值（舊值）建議使用對應fast*方法

RMap<String, User> map = redisson.getMap("user-list");
map.fastPut("1", new User(2L, "张三2", 22));
map.fastPutIfAbsent("2", new User(2L, "李四", 33));
map.fastRemove("1") ;
  • 1.
  • 2.
  • 3.
  • 4.

以上操作不會傳回對應key之前的舊值。

  • 非同步存資料
RFuture<User> f1 = map.putAsync("1", new User(2L, "张三2", 22)) ;
RFuture<Boolean> f2 = map.fastPutAsync("2", new User(2L, "李四", 33)) ;
RFuture<Long> f3 = map.fastRemoveAsync("2") ;
  • 1.
  • 2.
  • 3.

以上操作對應Redis資料結構。

HASH資料結構HASH資料結構

  • Map集合中key綁定Lock

上面得知，Map保存的資料是hash資料結構，我們可以將每一個key綁定到對應的Lock/ReadWriteLock/Semaphore/CountDownLatch。

RMap<String, User> map = redisson.getMap("user-list") ;
RLock lock = map.getLock(key) ;
lock.lock() ;
try {
  System.out.printf("当前线程: %s, 当前时间: %d%n", Thread.currentThread().getName(), System.currentTimeMillis()) ;
  TimeUnit.SECONDS.sleep(3) ;
} finally {
  lock.unlock() ;
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 本機快取

用於加快讀取操作速度，避免網路往返。它在Redisson 端快取地圖條目，執行讀取操作的速度是普通實現的 45 倍。支援本地快取的地圖物件實作了RLocalCachedMap,它擴充了java.util.concurrent.ConcurrentMap 介面。該對像是完全線程安全的。

// 配置缓存策略
final LocalCachedMapOptions<String, User> LOCAL_CACHE = LocalCachedMapOptions.<String, User>defaults()
      // 缓存大小
      .cacheSize(200)
      // 缓存模式
      .storeMode(StoreMode.LOCALCACHE_REDIS)
      // 删除策略
      .evictionPolicy(EvictionPolicy.LRU) ;
// 获取指定key本地缓存      
RLocalCachedMap<String,User> localCachedMap = redisson.getLocalCachedMap("user-list", LOCAL_CACHE) ;
User user = localCachedMap.get("1") ;
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.

本機快取實例物件同樣支援fast*及非同步方式，這裡不再贅述。

  • 事件監聽

Redisson 允許為每個RMap 物件綁定監聽器，RMap 物件允許追蹤資料上的追蹤事件。如下表，監聽類及事件

圖片圖片

如下範例：

RMap<String, User> map = redisson.getMap("user-list");
int deletedListener = map.addListener(new DeletedObjectListener() {
  @Override
  public void onDeleted(String name) {
    // ...
  }
});
int expredListener = map.addListener(new ExpiredObjectListener() {
  @Override
  public void onExpired(String name) {
    // ...
  }
});
int putListener = map.addListener(new MapPutListener() {
  @Override
  public void onPut(String name) {
    // ...
  }
});
int removeListener = map.addListener(new MapRemoveListener() {
  @Override
  public void onRemove(String name) {
    // ...
  }
});
// 删除监听器
map.removeListener(listenerId) ; // removeListener, putListener ...
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.

以上是關於Map集合的常用操作。

2.2 Set集合

基於Redis 的Java Set 物件實作了java.util.Set 介面。該對象完全線程安全。透過元素狀態比較保持元素的唯一性。 Redis 將集合大小限制為4 294 967 295 個元素。 Redis 使用序列化狀態檢查值的唯一性，而不是值的hashCode()/equals() 方法。

  • RSet類別關係
public interface RSet<V> extends Set<V>,...{}
  • 1.
  • 基本操作
RSet<User> set = redisson.getSet("user-set");
set.add(new User(1L, "张三", 33)) ;
set.add(new User(2L, "李四", 55)) ;
  • 1.
  • 2.
  • 3.

Redis中儲存使用的資料結構：

圖片

RSet使用Set集合。與RMap一樣，RSet也支援同步非同步方式操作資料。

RFuture<Boolean> f1 = set.addAsync(new User(1L, "张三", 33)) ;
RFuture<Boolean> f2 = set.addAsync(new User(2L, "李四", 55)) ;
  • 1.
  • 2.
  • 綁定Lock操作
RSet<User> set = redisson.getSet("user-set") ;
RLock lock = set.getLock(new User(1L, "张三", 33)) ;
lock.lock() ;
try {
  // ...
} finally {
  lock.unlock() ;
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 刪除策略

目前的Redis實作沒有設定值刪除功能。因此，過期的資料會被org.redisson.eviction.EvictionScheduler清除。它一次刪除300個過期條目。如果clean task每次刪除300項，它將每秒執行一次(最小執行延遲)。但如果目前的過期值小於前一個，則執行延遲將增加1.5倍。

RSetCache<User> set = redisson.getSetCache("user-set") ;
set.add(new User(3L, "阴阳路", 66), 180L, TimeUnit.SECONDS) ;
  • 1.
  • 2.
  • 事件監聽

與Map一樣Set也有對應的事件監聽，詳細查看Map中對應的說明。

  • Set排序

基於Redis 的Java 分散式 SortedSet 實作了java.util.SortedSet 介面。該對象線程安全。它使用比較器對元素進行排序並保持唯一性。對於字串資料類型，建議使用LexSortedSet 對象，以提高效能。

RSortedSet<Integer> set = redisson.getSortedSet("set-sort") ;
// 这里不可以写成lambda表达式：(o1, o2) -> Integer.compare(o1, o2)
set.trySetComparator(new Comparator<Integer>() {
  @Override
  public int compare(Integer o1, Integer o2) {
    return o1 > o2 ? 1 : (o1 < o2 ? -1 : 0)  ;
  }
}) ;
set.add(3) ;
set.add(1) ;
set.add(2) ;
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.

redis中產生如下2個key：

圖片圖片

set-sort對應的值：

圖片圖片

2.3 List集合

基於Redis 的Java 分散式List 物件實作了java.util.List 介面。它按插入順序保存元素。它有Async、Reactive 和RxJava3 介面。 Redis 限制清單大小為4 294 967 295 個元素。

  • RList類別關係
public interface RList<V> extends List<V>, ... {}
  • 1.
  • 基本操作
RList<User> list = redisson.getList("user-list");
User user = new User(1L, "张三", 10);
list.add(user) ;
User ret = list.get(0) ;
System.out.println("ret = " + ret) ;
list.remove(user) ;
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 事件監聽
RList<User> list = redisson.getList("user-list") ;
list.addListener(new ExpiredObjectListener() {
  @Override
  public void onExpired(String name) {
    // ...
  }
}) ;
// 其它事件
/**
 * DeletedObjectListener
 * ListAddListener
 * ListInsertListener
 * ListSetListener
 * ListRemoveListener
 * ListTrimListener
 */
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.

2.4 Queue隊列

基於Redis 的Java 分散式無界隊列對象，實作了java.util.Queue 介面。該對像是完全線程安全的。它有Async、Reactive 和RxJava3 介面。

  • RQueue類關係
public interface RQueue<V> extends Queue<V>, ... {}
  • 1.
  • 基本操作
RQueue<User> queue = redisson.getQueue("user-queue");
queue.add(new User()) ;
// 获取但不删除
User u1 = queue.peek() ;
// 获取并删除
User u2 = queue.poll() ;
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.

redis使用的資料結構：

圖片圖片

  • 事件監聽
RQueue<User> queue = redisson.getQueue("user-queue") ;
queue.addListener(new ExpiredObjectListener() {
  @Override
  public void onExpired(String name) {
    // ...
  }
}) ;
// 其它事件
/**
 * ListAddListener
 * ListInsertListener
 * ListRemoveListener
 */
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.

2.5 阻塞隊列

基於Redis 的Java 分散式無界BlockingQueue對象，實作了 java.util.concurrent.BlockingQueue介面。該對像是完全線程安全的。它有Async、Reactive 和RxJava3 介面。

  • 類關係
public interface RBlockingQueue<V> extends BlockingQueue<V>, ... {}
  • 1.
  • 基本操作
RBlockingQueue<User> queue = redisson.getBlockingQueue("user-blockqueue");
queue.offer(new User(1L, "哈哈", 22)) ;
// queue.offer(new User(2L, "嘿嘿", 33)) ;


User u1 = queue.peek() ;
User u2 = queue.poll() ;
// 这里会被阻塞，最多等待10s队列中有元素则直接返回
User u3 = queue.poll(10, TimeUnit.SECONDS) ;
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.

對應redis使用的資料結構：

圖片圖片

2.6 有界阻塞隊列

大致使用用途上面一致：

RBoundedBlockingQueue<SomeObject> queue = redisson.getBoundedBlockingQueue("user-capacity-queue");
// 设置容量大小
queue.trySetCapacity(2);


queue.offer(new User(1L, "张三", 20));
queue.offer(new User(2L, "李四", 10));
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.

Redisson提供了許多分散式的佇列實現，如還有雙端佇列，優先權佇列等，這裡就不一一展示了。