好用的Redisson

好用的Redisson

文章目录

  • 好用的Redisson
    • 介绍
    • 如何安装 Redisson
    • 如何编译运行 Redisson
    • 使用 RList 操作 Redis 列表
      • 示例
    • 使用 RMap 操作 Redis 哈希
      • 示例
    • 使用 RLock 实现 Redis 分布式锁
      • 示例
    • 使用 RAtomicLong 实现 Redis 原子操作
      • 示例
    • **获取分布式队列**:RedissonClient提供了分布式队列的实现,这可以帮助我们实现消息队列
    • **获取分布式发布订阅**:RedissonClient提供了分布式发布订阅的实现,这可以帮助我们实现消息的发布和订阅
    • RedissonClient提供了许多方法,以下列举了其中的一些:

介绍

作为 Java 开发人员,我们若想在程序中集成 Redis,必须使用 Redis 的第三方库。而 Redisson 就是用于在 Java 程序中操作 Redis 的库,它使得我们可以在程序中轻松地使用 Redis。Redisson 在 java.util 中常用接口的基础上,为我们提供了一系列具有分布式特性的工具类。

如何安装 Redisson

安装 Redisson 最便捷的方法是使用 Maven 或者 Gradle:

•Maven

<dependency>
    <groupId>org.redissongroupId>
    <artifactId>redissonartifactId>
    <version>3.11.4version>
dependency>

•Gradle

compile group: 'org.redisson', name: 'redisson', version: '3.11.4'

目前 Redisson 最新版是 3.11.4,当然你也可以通过搜索 Maven 中央仓库 mvnrepository[1] 来找到 Redisson 的各种版本。

如何编译运行 Redisson

安装 Redisson 后,只需使用 Java 编译器即可编译和运行 Redisson 代码:

javac RedissonExamples.java


java RedissonExamples

使用 RList 操作 Redis 列表

RedissonClient 是一个在 Java 中实现的 in-memory 数据库 Redis 的客户端。它提供了很多高级功能,如分布式对象、分布式锁、分布式集合等。

在 RedissonClient 中,RList 是用于表示 Redis 中的列表数据结构的一个接口。这个接口提供了很多用于操作列表的方法,下面是一些主要的:

  1. 添加元素
    • add(Object o): 在列表的末尾添加一个元素。
    • addAll(Collection c): 在列表的末尾添加一个集合的所有元素。
  2. 获取元素
    • get(int index): 获取指定索引位置的元素。
    • size(): 获取列表的大小。
  3. 修改元素
    • set(int index, Object element): 设置指定索引位置的元素。
  4. 删除元素
    • remove(Object o): 移除第一个出现的指定元素。
    • removeAll(Collection c): 移除所有出现的指定集合的元素。
    • clear(): 移除所有元素。
  5. 检查元素是否存在
    • contains(Object o): 检查列表是否包含指定的元素。
  6. 其他操作
    • addFirst(Object o): 在列表的头部添加一个元素。
    • addLast(Object o): 在列表的尾部添加一个元素。
    • removeFirst(Object o): 移除第一个出现的指定元素并返回它。
    • removeLast(Object o): 移除最后一个出现的指定元素并返回它。
    • move(int sourceIndex, int destIndex): 将指定索引位置的元素移动到另一个索引位置。
    • containsAll(Collection c): 检查列表是否包含所有指定的元素。
    • indexOf(Object o): 返回指定元素在列表中的索引,如果列表不包含该元素则返回 -1。
    • lastIndexOf(Object o): 返回指定元素在列表中的最后一个索引,如果列表不包含该元素则返回 -1。
  7. 排序和查找
    • sort(Comparator c): 根据给定的比较器对列表进行排序。
    • stream(), parallelStream(): 返回一个流,以便进行流式处理。
  8. 其他方法RList 还提供了很多其他方法,如获取子列表、获取随机元素等。

这只是 RList 接口中的一部分方法,实际上它还提供了更多的功能和操作。你可以查看 Redisson 的官方文档或源代码来获取更详细的信息和使用示例。

示例

import org.redisson.Redisson;
import org.redisson.api.RList;
import org.redisson.api.RedissonClient;


public class ListExamples {
    public static void main(String[] args) {
        // 默认连接上 127.0.0.1:6379
        RedissonClient client = Redisson.create();
        // RList 继承了 java.util.List 接口
        RList<String> nameList = client.getList("nameList");
        nameList.clear();
        nameList.add("bingo");
        nameList.add("name");
        nameList.add("https://github.com/demo");
        nameList.remove(-1);


        boolean contains = nameList.contains("name");
        System.out.println("List size: " + nameList.size());
        System.out.println("Is list contains name 'name': " + contains);
        nameList.forEach(System.out::println);


        client.shutdown();
    }
}

运行上面的代码时,可以获得以下输出:

List size: 2
Is list contains name 'name': true
bingo
yanglbme

使用 RMap 操作 Redis 哈希

RedissonClient中的RMap是一个用于在Redis中存储键值对数据的接口。它提供了许多用于操作映射表的方法,下面是一些主要的:

  1. 添加键值对
    • put(K key, V value): 添加或更新一个键值对。
    • putAll(Map m): 添加或更新一个映射表中的所有键值对。
  2. 获取值
    • get(Object key): 获取指定键的值。
    • get(Object key, V defaultValue): 获取指定键的值,如果键不存在则返回默认值。
  3. 删除键值对
    • remove(Object key): 删除指定键及其对应的值。
  4. 检查键是否存在
    • containsKey(Object key): 检查映射表中是否包含指定的键。
    • containsValue(Object value): 检查映射表中是否包含指定的值。
  5. 获取键的集合
    • keySet(): 返回映射表中所有键的集合。
  6. 获取值的集合
    • values(): 返回映射表中所有值的集合。
  7. 获取键值对的集合
    • entrySet(): 返回映射表中所有键值对的集合。
  8. 其他操作
    • putIfAbsent(K key, V value): 如果指定键不存在,则添加或更新一个键值对。
    • replace(K key, V value): 替换指定键的值。如果键不存在,则不执行任何操作。
    • replace(K key, V oldValue, V newValue): 替换与指定旧值匹配的所有键的值。
  9. 排序和查找
    • sort(Comparator c): 根据给定的比较器对映射表的键进行排序。
    • stream(), parallelStream(): 返回一个流,以便进行流式处理。
  10. 其他方法RMap 还提供了很多其他方法,如获取子映射表、获取随机键或值等。

这只是 RMap 接口中的一部分方法,实际上它还提供了更多的功能和操作。你可以查看 Redisson 的官方文档或源代码来获取更详细的信息和使用示例。

示例

import org.redisson.Redisson;
import org.redisson.api.RMap;
import org.redisson.api.RedissonClient;


public class MapExamples {
    public static void main(String[] args) {
        // 默认连接上127.0.0.1:6379
        RedissonClient client = Redisson.create();
        // RMap 继承了 java.util.concurrent.ConcurrentMap 接口
        RMap<String, String> map = client.getMap("personalInfo");
        map.put("name", "name");
        map.put("address", "adress");
        map.put("link", "https://link.com/demo");


        boolean contains = map.containsKey("link");
        System.out.println("Map size: " + map.size());
        System.out.println("Is map contains key 'link': " + contains);
        String value = map.get("name");
        System.out.println("Value mapped by key 'name': " + value);
        boolean added = map.putIfAbsent("link", "https://doocs.github.io") == null;
        System.out.println("Is value mapped by key 'link' added: " + added);
        client.shutdown();
    }
}

运行上面的代码时,将会看到以下输出:

Map size: 3
Is map contains key 'link': true
Value mapped by key 'name': name
Is value mapped by key 'link' added: false

使用 RLock 实现 Redis 分布式锁

RedissonClient中的RLock是一个用于在Redis中实现分布式锁的接口。它提供了许多用于操作锁的方法,下面是一些主要的:

  1. 获取锁
    • lock(): 获取锁,如果锁已被其他客户端持有,则当前客户端会阻塞等待。
    • lock(long leaseTime, TimeUnit unit): 获取锁,并设置锁的租用时间。租用时间过后,锁会自动释放。
  2. 释放锁
    • unlock(): 释放锁。在调用unlock()方法之前,必须确保已经通过调用lock()方法获取了锁。
  3. 尝试获取锁
    • tryLock(): 尝试获取锁,如果锁未被其他客户端持有,则立即获取锁并返回true,否则返回false。
    • tryLock(long waitTime, long leaseTime, TimeUnit unit): 尝试获取锁,如果锁未被其他客户端持有,则等待指定的等待时间后获取锁,并设置锁的租用时间。如果等待时间内无法获取锁,则返回false。
  4. 重入锁
    • lock()tryLock() 方法可以用于重入锁,这意味着同一个线程可以多次获取同一个锁,而不会导致死锁。
  5. 其他操作
    • isLocked(): 检查锁是否被当前客户端持有。
    • isHeldByCurrentThread(): 检查当前线程是否持有该锁。
    • getHoldCount(): 返回当前线程对锁的持有次数。
    • getQueueLength(): 返回等待获取该锁的线程数。
  6. 过期和自动解锁
    你可以使用expireAfterWriteexpireAfterAccess方法为锁设置过期时间。这样,如果一个客户端在一段时间内无法释放锁(例如由于崩溃),那么锁会自动释放。
  7. 删除和重命名
    使用deleterename方法可以删除或重命名锁。
  8. 公平性
    通过setFair方法可以设置锁的公平性。公平锁会按照线程请求锁的顺序来授予锁,而非公平锁则不会保证这个顺序。
  9. 其他方法:RLock 还提供了很多其他方法,如尝试获取并立即释放锁、获取并增加持有次数等。

这只是 RLock 接口中的一部分方法,实际上它还提供了更多的功能和操作。你可以查看 Redisson 的官方文档或源代码来获取更详细的信息和使用示例。

示例

import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;


public class LockExamples {
    public static void main(String[] args) throws InterruptedException {
        // 默认连接上127.0.0.1:6379
        RedissonClient client = Redisson.create();
        // RLock 继承了 java.util.concurrent.locks.Lock 接口
        RLock lock = client.getLock("lock");


        lock.lock();
        System.out.println("lock acquired");


        Thread t = new Thread(() -> {
            RLock lock1 = client.getLock("lock");
            lock1.lock();
            System.out.println("lock acquired by thread");
            lock1.unlock();
            System.out.println("lock released by thread");
        });


        t.start();
        t.join(1000);


        lock.unlock();
        System.out.println("lock released");


        t.join();


        client.shutdown();
    }
}

此代码将产生以下输出:

lock acquired
lock released
lock acquired by thread
lock released by thread

使用 RAtomicLong 实现 Redis 原子操作

RedissonClient中的RAtomicLong是一个在Redis中实现的分布式原子长整型数据的接口。它提供了许多用于操作原子长整型数据的方法,下面是一些主要的:

  1. 增加和减少
    • incrementAndGet(): 原子地增加当前值,并返回增加后的值。
    • decrementAndGet(): 原子地减少当前值,并返回减少后的值。
  2. 设置值
    • set(long newValue): 原子地设置新的值。
  3. 获取值
    • get(): 获取当前值。
  4. 比较和交换
    • compareAndSet(long expect, long update): 原子地比较当前值与期望值,如果相等,则将当前值更新为新值,并返回true,否则不执行任何操作并返回false。
  5. 其他操作
    • addAndGet(long delta): 原子地增加当前值,并返回增加后的值。
    • getAndSet(long newValue): 原子地设置新的值,并返回旧值。
    • getAndAdd(long delta): 原子地增加当前值,并返回增加前的值。
  6. 获取和设置偏移量
    使用getOffsetsetOffset方法可以获取和设置偏移量,这可以用于实现原子操作。
  7. 其他方法:RAtomicLong 还提供了很多其他方法,如尝试获取并立即释放锁、获取并增加持有次数等。

这只是 RAtomicLong 接口中的一部分方法,实际上它还提供了更多的功能和操作。你可以查看 Redisson 的官方文档或源代码来获取更详细的信息和使用示例。

示例

import org.redisson.Redisson;
import org.redisson.api.RAtomicLong;
import org.redisson.api.RedissonClient;


public class AtomicLongExamples {
    public static void main(String[] args) {
        // 默认连接上127.0.0.1:6379
        RedissonClient client = Redisson.create();
        RAtomicLong atomicLong = client.getAtomicLong("myLong");


        System.out.println("Init value: " + atomicLong.get());


        atomicLong.incrementAndGet();
        System.out.println("Current value: " + atomicLong.get());


        atomicLong.addAndGet(10L);
        System.out.println("Final value: " + atomicLong.get());


        client.shutdown();
    }
}

此代码的输出将是:

Init value: 0
Current value: 1
Final value: 11

获取分布式队列:RedissonClient提供了分布式队列的实现,这可以帮助我们实现消息队列

RedissonClient中的RQueue是一个在Redis中实现的分布式队列的接口。它提供了许多用于操作队列的方法,下面是一些主要的:

  1. 添加元素
    • add(E e): 将指定的元素添加到队列的末尾。
    • offer(E e): 将指定的元素添加到队列的末尾,如果队列已满,则不执行任何操作。
  2. 移除元素
    • remove(): 移除并返回队列的头元素。如果队列为空,则不执行任何操作。
    • poll(): 移除并返回队列的头元素,如果队列为空,则返回null。
  3. 获取元素
    • element(): 获取但不移除队列的头元素,如果队列为空,则抛出异常。
    • peek(): 获取但不移除队列的头元素,如果队列为空,则返回null。
  4. 检查元素
    • contains(Object o): 检查队列是否包含指定的元素。
  5. 清空队列
    • clear(): 移除队列中的所有元素。
  6. 获取队列的大小
    • size(): 返回队列中的元素个数。
  7. 阻塞队列操作:RQueue 还提供了阻塞版本的获取和移除方法,如 takeput,它们可以使当前线程等待直到获取或添加元素为止。
  8. 其他方法:RQueue 还提供了很多其他方法,如检查队列是否为空、检查是否包含指定元素等。

这只是 RQueue 接口中的一部分方法,实际上它还提供了更多的功能和操作。你可以查看 Redisson 的官方文档或源代码来获取更详细的信息和使用示例。

获取分布式发布订阅:RedissonClient提供了分布式发布订阅的实现,这可以帮助我们实现消息的发布和订阅

RedissonClient 中的 RPubSub 是一个接口,它代表 Redis 的发布/订阅功能。Redis 的发布/订阅模型允许消息的生产者(发布者)发送消息到一个或多个消费者(订阅者)而无需知道它们是谁。在 Redisson 中,RPubSub 提供了一套 API 来实现这种发布/订阅模式。

以下是 RPubSub 提供的主要方法:

  1. 订阅
    • subscribe(String... channelNames): 订阅一个或多个频道。当有消息发布到这些频道时,订阅者会收到这些消息。
    • psubscribe(String... patternChannelNames): 订阅一个或多个模式频道。模式频道使用模式匹配来过滤消息。
  2. 取消订阅
    • unsubscribe(String... channelNames): 取消订阅一个或多个频道。
    • punsubscribe(String... patternChannelNames): 取消订阅一个或多个模式频道。
  3. 发布消息
    • 需要注意的是,RPubSub 本身并不直接提供发布消息的方法。发布消息通常是通过 RTopic 接口来完成的,你可以通过 RedissonClientgetTopic 方法来获取一个 RTopic 实例,然后调用其 publish 方法来发布消息。
  4. 监听消息
    • addListener(MessageListener listener): 添加一个消息监听器,该监听器会在接收到订阅的频道或模式频道的消息时被调用。
    • removeListener(MessageListener listener): 移除一个消息监听器。
  5. 其他方法
    • getChannelName(): 获取当前订阅的频道名称(仅适用于单个频道的订阅者)。
    • getPatternChannelName(): 获取当前订阅的模式频道名称(仅适用于模式频道的订阅者)。

RPubSub 通常与 RTopic 一起使用,RTopic 代表一个可以发布消息的频道。你可以通过 RedissonClientgetTopic 方法获取一个 RTopic 实例,并使用它来发布消息。

下面是一个简单的使用示例:

RedissonClient redisson = Redisson.create();  
  
// 获取一个 RTopic 实例  
RTopic<String> topic = redisson.getTopic("anyChannel");  
  
// 创建一个 RPubSub 实例并订阅频道  
RPubSub<String> pubSub = redisson.getPubSub();  
pubSub.addListener(new MessageListener<String>() {  
    @Override  
    public void onMessage(String channel, String message) {  
        System.out.println("Received message: " + message + " from channel: " + channel);  
    }  
});  
  
// 订阅频道  
pubSub.subscribe("anyChannel");  
  
// 发布消息  
topic.publish("Hello, Redis!");  
  
// ... 在某个时刻取消订阅  
pubSub.unsubscribe("anyChannel");  
  
// 关闭 Redisson 客户端  
redisson.shutdown();

需要注意的是,上面的示例代码中,发布和订阅操作是在同一个进程内完成的,但在实际应用中,发布者和订阅者通常是分布在不同进程或机器上的。此外,订阅操作通常是阻塞的,这意味着订阅者会一直监听频道直到它被取消订阅或程序被终止。在实际应用中,你可能需要在一个单独的线程中处理订阅逻辑。

RedissonClient提供了许多方法,以下列举了其中的一些:

  1. 创建锁:RedissonClient提供了分布式锁的实现,这可以帮助我们在分布式环境中实现互斥访问。以下是创建和使用锁的示例代码:
RLock lock = redissonClient.getLock("myLock");  
lock.lock();  
try {  
    // 在这里执行需要互斥的操作  
} finally {  
    lock.unlock();  
}
  1. 获取分布式集合:RedissonClient提供了分布式集合的实现,如List、Set、Queue等。以下是获取和使用分布式List的示例代码:
RList<String> list = redissonClient.getList("myList");  
list.add("item1");  
list.add("item2");  
list.add("item3");
  1. 获取分布式映射表:RedissonClient提供了分布式映射表的实现,这可以帮助我们存储键值对。以下是获取和使用分布式映射表的示例代码:
RMap<String, String> map = redissonClient.getMap("myMap");  
map.put("key1", "value1");  
map.put("key2", "value2");  
String value = map.get("key1");
  1. 获取分布式哈希表:RedissonClient提供了分布式哈希表的实现,这可以帮助我们存储复杂的数据结构。以下是获取和使用分布式哈希表的示例代码:
RMap<String, Person> map = redissonClient.getMap("myHashTable");  
Person person = new Person("John", 30);  
map.put("key1", person);  
Person value = map.get("key1");
  1. 获取分布式队列:RedissonClient提供了分布式队列的实现,这可以帮助我们实现消息队列。以下是获取和使用分布式队列的示例代码:
RQueue<String> queue = redissonClient.getQueue("myQueue");  
queue.offer("item1");  
queue.offer("item2");  
String item = queue.poll(); // 获取并移除队列的头元素
  1. 获取分布式发布订阅:RedissonClient提供了分布式发布订阅的实现,这可以帮助我们实现消息的发布和订阅。以下是使用发布订阅的示例代码:
RPubSub<String, String> pubSub = redissonClient.getPubSub("myPubSub");  
pubSub.subscribe("channel1", new MessageListener<String>() { // 订阅一个频道并设置监听器  
    @Override  
    public void onMessage(String channel, String message) {  
        // 处理消息的逻辑  
    }  
});  
pubSub.publish("channel1", "message1"); // 发布一条消息到指定的频道

ring item = queue.poll(); // 获取并移除队列的头元素


1. **获取分布式发布订阅**:RedissonClient提供了分布式发布订阅的实现,这可以帮助我们实现消息的发布和订阅。以下是使用发布订阅的示例代码:

```java
RPubSub pubSub = redissonClient.getPubSub("myPubSub");  
pubSub.subscribe("channel1", new MessageListener() { // 订阅一个频道并设置监听器  
    @Override  
    public void onMessage(String channel, String message) {  
        // 处理消息的逻辑  
    }  
});  
pubSub.publish("channel1", "message1"); // 发布一条消息到指定的频道

以上是RedissonClient中的一些常用方法,实际上RedissonClient还提供了许多其他功能和操作,你可以查看Redisson的官方文档或源代码来获取更详细的信息和使用示例。

你可能感兴趣的:(redis,分布式)