Redis分布式客户端之Redisson的基本使用

最新推荐文章于 2024-08-10 11:34:27 发布
最新推荐文章于 2024-08-10 11:34:27 发布
阅读量4.2k 收藏 2
点赞数
分类专栏： redis

转载：https://blog.csdn.net/u010963948/article/details/79240050

这里先简单介绍下我的项目里面的基本使用，redis服务采用的是三主三从模式。

1、配置文件代码如下：

[java]  view plain  copy
  1. package com.whb.redisson.demoOne.properties;  
  2.   
  3. import org.redisson.config.ClusterServersConfig;  
  4. import org.springframework.boot.context.properties.ConfigurationProperties;  
  5. import org.springframework.context.annotation.Configuration;  
  6.   
  7. /** 
  8.  * @author whb 
  9.  * @date 2018年2月2日 下午3:14:54  
  10.  * @Description: redis的集群配置（还有其他主从配置BaseMasterSlaveServersConfig等） 
  11.  */  
  12. @Configuration  
  13. @ConfigurationProperties(prefix = "dislock.redisson.clusterServersConfig")  
  14. public class ClusterServerConfigProperties extends ClusterServersConfig {  
  15. }  
2、初始化文件如下：

[java]  view plain  copy
  1. package com.whb.redisson.demoOne;  
  2.   
  3. import java.net.URI;  
  4. import java.util.List;  
  5.   
  6. import org.redisson.Redisson;  
  7. import org.redisson.api.RedissonClient;  
  8. import org.redisson.config.ClusterServersConfig;  
  9. import org.redisson.config.Config;  
  10. import org.springframework.beans.BeanUtils;  
  11. import org.springframework.beans.factory.annotation.Autowired;  
  12. import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;  
  13. import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;  
  14. import org.springframework.boot.context.properties.EnableConfigurationProperties;  
  15. import org.springframework.context.annotation.Bean;  
  16. import org.springframework.context.annotation.Configuration;  
  17. import org.springframework.context.annotation.Primary;  
  18.   
  19. import com.whb.redisson.demoOne.properties.ClusterServerConfigProperties;  
  20.   
  21. /** 
  22.  * @author whb 
  23.  * @date 2018年2月2日 下午3:16:25  
  24.  * @Description: 分布式锁，解决资源竞争问题 
  25.  */  
  26. @Configuration  
  27. @ConditionalOnClass(Config.class)  
  28. @EnableConfigurationProperties(ClusterServerConfigProperties.class)  
  29. public class EnableRedissonAutoConfiguration {  
  30.   
  31.     /** 集群的配置 */  
  32.     @Autowired  
  33.     private ClusterServerConfigProperties clusterServerConfigProperties;  
  34.   
  35.   
  36.     /** 
  37.      * 集群模式自动装配 
  38.      * @return 
  39.      */  
  40.     @Bean  
  41.     @Primary  
  42.     //@ConditionalOnExpression("'${dislock.redisson.clusterServersConfig.idleConnectionTimeout}'=='10000'")  
  43.     @ConditionalOnProperty(prefix = "dislock.redisson",name = "startup",matchIfMissing = false)  
  44.     public RedissonClient redissonCluster() {  
  45.         Config config = new Config();  
  46.         ClusterServersConfig serverConfig = config.useClusterServers();  
  47.         BeanUtils.copyProperties(clusterServerConfigProperties,serverConfig);  
  48.         List<URI> nodeAddresses = clusterServerConfigProperties.getNodeAddresses();  
  49.   
  50.         int size = nodeAddresses.size();  
  51.         String[] address = new String[size];  
  52.         for(int i=0;i<size;i++){  
  53.             address[i] = nodeAddresses.get(i).toString();  
  54.         }  
  55.   
  56.         serverConfig.addNodeAddress(address);  
  57.   
  58.         return Redisson.create(config);  
  59.     }  
  60. }  

3、使用教程如下：

[java]  view plain  copy
  1. @Autowired  
  2.     RedissonClient redissonClient;  
  3.       
  4.     public void getLock(){  
  5.         RLock lock = redissonClient.getLock("123");  
  6.         try{  
  7.             boolean b = lock.tryLock(5, 20, TimeUnit.SECONDS);  
  8.             if(!b){  
  9.                 throw new RuntimeException("-------------");  
  10.             }  
  11.             Thread.sleep(500L);  
  12.         } catch (InterruptedException e) {  
  13.             e.printStackTrace();  
  14.         } finally {  
  15.             lock.unlock();  
  16.         }  
  17.     }  

4、Redission的基本使用如下：

简介

Redisson - 是一个高级的分布式协调Redis客服端，能帮助用户在分布式环境中轻松实现一些Java的对象 (Bloom filter, BitSet, Set, SetMultimap, ScoredSortedSet, SortedSet, Map, ConcurrentMap, List, ListMultimap, Queue, BlockingQueue, Deque, BlockingDeque, Semaphore, Lock, ReadWriteLock, AtomicLong, CountDownLatch, Publish / Subscribe, HyperLogLog)。

支持Redis多种连接模式

集群模式



Config config = new Config();
config.useClusterServers()
    .setScanInterval(2000) // cluster state scan interval in milliseconds
    .addNodeAddress("127.0.0.1:7000", "127.0.0.1:7001")
    .addNodeAddress("127.0.0.1:7002");
RedissonClient redisson = Redisson.create(config);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

单例模式



// connects to 127.0.0.1:6379 by default
RedissonClient redisson = Redisson.create();
Config config = new Config();
config.useSingleServer().setAddress("myredisserver:6379");
RedissonClient redisson = Redisson.create(config);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

哨兵模式


Config config = new Config();
config.useSentinelServers()
    .setMasterName("mymaster")
    .addSentinelAddress("127.0.0.1:26389", "127.0.0.1:26379")
    .addSentinelAddress("127.0.0.1:26319");
RedissonClient redisson = Redisson.create(config);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

主从模式


Config config = new Config();
config.useMasterSlaveServers()
    .setMasterAddress("127.0.0.1:6379")
    .addSlaveAddress("127.0.0.1:6389", "127.0.0.1:6332", "127.0.0.1:6419")
    .addSlaveAddress("127.0.0.1:6399");
RedissonClient redisson = Redisson.create(config);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

操作执行

Redisson支持自动重试策略，默认是重试3次，间隔为1000ms。除了支持同步操作外，还支持异步方式和响应方式。


RedissonClient client = Redisson.create(config);
RAtomicLong longObject = client.getAtomicLong('myLong');
// sync way
longObject.compareAndSet(3, 401);
// async way
longObject.compareAndSetAsync(3, 401);
RedissonReactiveClient client = Redisson.createReactive(config);
RAtomicLongReactive longObject = client.getAtomicLong('myLong');
// reactive way
longObject.compareAndSet(3, 401);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

多种序列号方式

Codec class name Description 
org.redisson.codec.JsonJacksonCodec Jackson JSON codec. Default codec 
org.redisson.codec.CborJacksonCodec CBOR binary json codec 
org.redisson.codec.MsgPackJacksonCodec MsgPack binary json codec 
org.redisson.codec.KryoCodec Kryo binary codec 
org.redisson.codec.SerializationCodec JDK Serialization codec 
org.redisson.codec.FstCodec FST up to 10 times faster and 100% JDK Serialization compatible codec 
org.redisson.codec.LZ4Codec LZ4 compression codec 
org.redisson.codec.SnappyCodec Snappy compression codec 
org.redisson.client.codec.StringCodec String codec 
org.redisson.client.codec.LongCodec Long codec

分布式对象

分布式Object



RBucket<AnyObject> bucket = redisson.getBucket("anyObject");
bucket.set(new AnyObject(1));
AnyObject obj = bucket.get();
bucket.trySet(new AnyObject(3));
bucket.compareAndSet(new AnyObject(4), new AnyObject(5));
bucket.getAndSet(new AnyObject(6));
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

分布式BitSet


RBitSet set = redisson.getBitSet("simpleBitset");
set.set(0, true);
set.set(1812, false);
set.clear(0);
set.addAsync("e");
set.xor("anotherBitset");
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

分布式Lock


Redisson redisson = Redisson.create();
RLock lock = redisson.getLock("anyLock");
// Most familiar locking method
lock.lock();
// Lock time-to-live support
// releases lock automatically after 10 seconds
// if unlock method not invoked
lock.lock(10, TimeUnit.SECONDS);
// Wait for 100 seconds and automatically unlock it after 10 seconds
boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
...
lock.unlock();
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

分布式MultiLock


RLock lock1 = redissonInstance1.getLock("lock1");
RLock lock2 = redissonInstance2.getLock("lock2");
RLock lock3 = redissonInstance3.getLock("lock3");
RedissonMultiLock lock = new RedissonMultiLock(lock1, lock2, lock3);
lock.lock();
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

分布式ReadWriteLock



RReadWriteLock rwlock = redisson.getLock("anyRWLock");
// Most familiar locking method
rwlock.readLock().lock();
// or
rwlock.writeLock().lock();
// Lock time-to-live support
// releases lock automatically after 10 seconds
// if unlock method not invoked
rwlock.readLock().lock(10, TimeUnit.SECONDS);
// or
rwlock.writeLock().lock(10, TimeUnit.SECONDS);
// Wait for 100 seconds and automatically unlock it after 10 seconds
boolean res = rwlock.readLock().tryLock(100, 10, TimeUnit.SECONDS);
// or
boolean res = rwlock.writeLock().tryLock(100, 10, TimeUnit.SECONDS);
...
lock.unlock();
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

分布式Semaphore


RSemaphore semaphore = redisson.getSemaphore("semaphore");
semaphore.acquire();
semaphore.acquire(23);
semaphore.tryAcquire();
semaphore.tryAcquire(23, TimeUnit.SECONDS);
semaphore.release(10);
semaphore.release();
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

分布式AtomicLong


RAtomicLong atomicLong = redisson.getAtomicLong("myAtomicLong");
atomicLong.set(3);
atomicLong.incrementAndGet();
atomicLong.get();
  • 1
  • 2
  • 3
  • 4
  • 5

分布式AtomicDouble


RAtomicDouble atomicDouble = redisson.getAtomicDouble("myAtomicDouble");
atomicDouble.set(2.81);
atomicDouble.addAndGet(4.11);
atomicDouble.get();
  • 1
  • 2
  • 3
  • 4
  • 5

分布式CountDownLatch


RCountDownLatch latch = redisson.getCountDownLatch("anyCountDownLatch");
latch.trySetCount(1);
latch.await();
// in other thread or other JVM
RCountDownLatch latch = redisson.getCountDownLatch("anyCountDownLatch");
latch.countDown();
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

Topic


RTopic<SomeObject> topic = redisson.getTopic("anyTopic");
topic.addListener(new MessageListener<SomeObject>() {
    @Override
    public void onMessage(String channel, SomeObject message) {
        //...
    }
});
// in other thread or JVM
RTopic<SomeObject> topic = redisson.getTopic("anyTopic");
long clientsReceivedMessage = topic.publish(new SomeObject());
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

Topic patttern


// subscribe to all topics by `topic1.*` pattern
RPatternTopic<Message> topic1 = redisson.getPatternTopic("topic1.*");
int listenerId = topic1.addListener(new PatternMessageListener<Message>() {
    @Override
    public void onMessage(String pattern, String channel, Message msg) {
         Assert.fail();
    }
});
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

分布式集合

分布式Map

除此之外，还支持Multimap，这里不列出


RMap<String, SomeObject> map = redisson.getMap("anyMap");
SomeObject prevObject = map.put("123", new SomeObject());
SomeObject currentObject = map.putIfAbsent("323", new SomeObject());
SomeObject obj = map.remove("123");
map.fastPut("321", new SomeObject());
map.fastRemove("321");
Future<SomeObject> putAsyncFuture = map.putAsync("321");
Future<Void> fastPutAsyncFuture = map.fastPutAsync("321");
map.fastPutAsync("321", new SomeObject());
map.fastRemoveAsync("321");
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

Map eviction

现在Redis没有过期清空Map中的某个entry的功能，只能是清空Map所有的entry。Redission提供了这种功能。


RMapCache<String, SomeObject> map = redisson.getMapCache("anyMap");
// ttl = 10 minutes, 
map.put("key1", new SomeObject(), 10, TimeUnit.MINUTES);
// ttl = 10 minutes, maxIdleTime = 10 seconds
map.put("key1", new SomeObject(), 10, TimeUnit.MINUTES, 10, TimeUnit.SECONDS);
// ttl = 3 seconds
map.putIfAbsent("key2", new SomeObject(), 3, TimeUnit.SECONDS);
// ttl = 40 seconds, maxIdleTime = 10 seconds
map.putIfAbsent("key2", new SomeObject(), 40, TimeUnit.SECONDS, 10, TimeUnit.SECONDS);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

分布式Set


RSet<SomeObject> set = redisson.getSet("anySet");
set.add(new SomeObject());
set.remove(new SomeObject());
  • 1
  • 2
  • 3
  • 4

除此之外还有，还支持Set eviction， SortedSet, ScoredSortedSet, LexSortedSet

分布式List


RList<SomeObject> list = redisson.getList("anyList");
list.add(new SomeObject());
list.get(0);
list.remove(new SomeObject());
  • 1
  • 2
  • 3
  • 4
  • 5

分布式Blocking Queue


RBlockingQueue<SomeObject> queue = redisson.getBlockingQueue("anyQueue");
queue.offer(new SomeObject());
SomeObject obj = queue.peek();
SomeObject someObj = queue.poll();
SomeObject ob = queue.poll(10, TimeUnit.MINUTES);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

除此之外，还支持Queue, Deque, Blocking Deque

其他功能

执行批量命令


RBatch batch = redisson.createBatch();
batch.getMap("test").fastPutAsync("1", "2");
batch.getMap("test").fastPutAsync("2", "3");
batch.getMap("test").putAsync("2", "5");
batch.getAtomicLongAsync("counter").incrementAndGetAsync();
batch.getAtomicLongAsync("counter").incrementAndGetAsync();
List<?> res = batch.execute();


全威指南
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Redis分布式锁实现Redisson 15问
uuqaz的博客
05-30 1182
在一个分布式系统中，由于涉及到多个实例同时对同一个资源加锁的问题，像传统的synchronized、ReentrantLock等单进程情况加锁的api就不再适用，需要使用分布式锁来保证多服务实例之间加锁的安全性。常见的分布式锁的实现方式有zookeeper和redis等。而由于redis分布式锁相对于比较简单，在实际的项目中，redis分布式锁被用于很多实际的业务场景中。 redis分布式锁的实现中又以Redisson比较出名，所以本文来着重看一下Redisson是如何实现分布式锁的，以及Rediss..
Redis分布式锁、Redisson原理
qq_44027353的博客
03-25 694
方法加锁，但是只会有一个线程加锁成功，如果线程1加锁成功了那么就会另外开启一个线程，默认每隔10s去检查锁是否还存在，如果还存在则重新设置锁过期时间为30秒。如果加锁成功是返回null，如果加锁没成功是返回的锁过期时间，所以这里接下来就是一个while(true)死循环，不断尝试获取锁。核心思想是首先等一段时间，延迟执行TimerTask类的run()方法，等待的时间是key过期时间的三分之一，默认是10s。方法没有加锁成功，那么返回的是这个锁的过期时间，那么接下来也就回到了加锁部分的第一张图中了。
Redisson 类介绍！
不知所终的博客
05-07 584
Redis 是最流行的 NoSQL 数据库解决方案之一，而 Java 是世界上最流美的编程语言之一。虽然两者看起来很自然地在一起“工作”，但是要知道，Redis 其实并没有对 Java 提供原生支持。 相反，作为 Java 开发人员，我们若想在程序中集成 Redis，必须使用 Redis 的第三方库。而 Redisson 就是用于在 Java 程序中操作 Redis 的库，它使得我们可以在程序中轻...
技术栈入门-----Redisson
我从不打没有准备的仗！
02-17 236
技术栈入门-----Redisson
玩转Redis！非常强大的Redisson分布式集合
最新发布
330553352的专栏
08-10 507
该对象完全线程安全。支持本地缓存的地图对象实现了RLocalCachedMap,它扩展了 java.util.concurrent.ConcurrentMap 接口。通过使用Redisson，开发者可以像使用传统Java集合类一样，在分布式系统中进行数据的增删改查操作，而无需担心数据在不同节点之间的同步和一致性问题。基于 Redis 的 Java 分布式无界队列对象，实现了 java.util.Queue 接口。Redisson提供了很多分布式的队列实现，如还有双端队列，优先级队列等，这里就不一一展示了。
Redis(十六)——Springboot整合Redisson超卖问题解决
专注写bug
01-14 1051
前言 上一篇博客中，根据超卖问题，逐步分析了在不同环境下，多种思路的局限性。 这篇博客具体针对上一篇博客中存在的问题做合理解决。 Redisson查考资料 redisson 官方github文档 Redisson和jedis都是java实现的Redis的客户端。但Redisson比jedis具有更多的功能。 依赖引入 <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</
Redis之Redisson原理详解
上善若泪
06-11 4126
Redisson顾名思义，Redis的儿子，本质上还是Redis加锁，不过是对Redis做了很多封装，它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。
Redisson启动及服务、命令模式分析
weixin_40455124的博客
07-07 1032
以AtomicDoubleExamples为入口，初步分析redisson启动及命令、服务 Redisson 启动的主类为org.redisson.Redisson, 启动主要是初始化connection pool，还有两个比较少用的evictionScheduler（local cache housekeeping？）及local cache用的WriteBehindService ？ Red...
记录redisson实现redis分布式事务锁
04-24
本篇文章将详细探讨如何使用Redisson实现Redis分布式事务锁，以及在Spring Boot环境中如何进行集成。 首先，Redis作为一个内存数据库，其高速读写性能使其成为实现分布式锁的理想选择。分布式锁的主要作用是在多...
在一个分布式系统中，Redis分布式锁实现Redisson 15问
m0_73583876的博客
10-13 599
在一个分布式系统中，Redis分布式锁实现Redisson 15问
Redisson一分钟学会【通俗易懂】
black_pp的博客
07-20 4683
Redisson介绍，Redisson教学，Redisson实操，Redisson分布式锁，Redisson缓存
在Spring Boot项目中使用Redisson
Go_ahead_forever的博客
09-29 3955
Redission是一个基于Java的分布式缓存和分布式任务调度框架，用于处理分布式系统中的缓存和任务队列。它是一个开源项目，旨在简化分布式系统的开发和管理。：Redission支持分布式缓存，可以将数据存储在分布式环境中，以提高性能和可用性。它提供了各种数据结构，如分布式Map、Set、List、Queue等，可以用来存储和操作数据。：Redission提供了分布式锁的功能，允许多个线程或多个应用程序在分布式环境中协调对共享资源的访问，以避免竞态条件。
SpringBoot使用Redisson 实现分布式锁
少年有事问春风
09-14 770
SpringBoot使用Redisson 实现分布式锁
Redisson操作Redis之基础篇
热门推荐
undergrowth的专栏
06-01 4万+
记录redis的学习笔记  基础篇 redis是一个开源的，C语言编写、bsd协议的，键值对的缓存和存储的、通常被作为NoSql的内存数据库 键值包含--字符串、列表、集合、有序集合、散列表、位图、hyperloglogs set key value -->设置键值对 get key --获取键对应的值 getset key field--设置新的键值 并
Redisson连接Redis单机&集群&哨兵配置示例
idto315的博客
09-21 6381
基于spring-boot-starter-data-redis原生配置集成Redission，连接不同模式（单机/主从/哨兵/集群）的Redis服务
SpringBoot3.0.3集成Redisson3.20.0
pandalive的博客
03-02 1913
使用Redisson可以方便地实现分布式锁、分布式限流、分布式任务调度和分布式缓存等功能，能够提高分布式应用程序的性能和可靠性。Redisson提供了分布式缓存的实现，可以帮助我们实现分布式缓存的读写、过期时间等功能。在分布式系统中，可能需要对任务进行分布式调度，Redisson提供了分布式任务调度的实现，可以帮助我们实现任务的定时执行、延迟执行等功能。
redissonclient类_Redisson的使用
gb4215287的博客
08-18 9012
java分布式锁
SpringBoot之使用Redisson实现分布式锁（秒杀系统）
My_SweetXue的博客
09-01 600
前面讲完了Redis的分布式锁的实现，接下来讲Redisson的分布式锁的实现，一般提及到Redis的分布式锁我们更多的使用的是Redisson的分布式锁，Redis的官方也是建议我们这样去做的。Redisson点我可以直接跳转到Redisson的官方文档。 1.1、引入Maven依赖 <dependency> <groupId>org.redisson</groupId> <artifact...
Redis分布式锁实战：lua脚本与Redisson实现
总结来说，Redis分布式锁的核心在于利用Redis的原子操作（如`setnx`和`del`）以及lua脚本的非阻塞特性，保证在多节点环境下对共享资源的并发控制。Redisson则提供了一种更高层次的封装，使得分布式锁的使用更为简洁...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值