Redisson教程

我就是我 2022-06-15 07:20 252阅读 0赞

*  # **Redisson****入门** #
 *  　　　　Author:Ricky  Date:2017-04-24
    
     *  # **Redisson概述** #
    
          [Redisson][]是架设在[Redis][]基础上的一个Java驻内存数据网格（In-Memory Data Grid）。充分的利用了Redis键值数据库提供的一系列优势，基于Java实用工具包中常用接口，为使用者提供了一系列具有分布式特性的常用工具类。使得原本作为协调单机多线程并发程序的工具包获得了协调分布式多机多线程并发系统的能力，大大降低了设计和研发大规模分布式系统的难度。同时结合各富特色的分布式服务，更进一步简化了分布式环境中程序相互之间的协作。
    
    　　Redisson始于2013年12月22日，至今已有三年多的发展，日趋成熟。
    
    　　地址：https://github.com/redisson/redisson
    
    # **适用场景** #
    
    　　分布式应用，分布式缓存，分布式回话管理，分布式服务（任务，延迟任务，执行器），分布式redis客户端
    
    # **案例** #
    
    　　百度、NetFlix等都在使用。
    
     *  # Redisson功能![562629-20170424160738475-283091523.png][] #
     *  ## Redisson功能 ##
        
         *  支持同步/异步/异步流/管道流方式连接
         *  多样化数据序列化
         *  集合数据分片
         *  分布式对象
         *  分布式集合
         *  分布式锁和同步器
         *  分布式服务
         *  独立节点模式
         *  三方框架整合
     *  # HelloWorld  #
    
    **引入依赖包** 
    
    <dependency>  
       <groupId>org.redisson</groupId>  
       <artifactId>redisson</artifactId>  
       <version>3.3.2</version>  
     </dependency>
    
    **程序化配置方法** 
    
    **        ** Config config = new Config(); 
    
             config. useSingleServer().setAddress("127.0.0.1:6379");
    
             RedissonClient redisson = Redisson.create(config);
    
    **文件方式配置**
    
             Config config = Config.fromJSON(new File("config-file.json")); 
    
             Config config = Config.fromYAML(new File("config-file.yaml")); RedissonClient RedissonClient  redisson = Redisson.create(config);
    
    **Spring****方式** 
    
             <redisson:client> 
    
                       <redisson:single-server address=“127.0.0.1:6379" /> 
    
             </redisson:client>
    
    HelloWorld 3 
    
    **验证是否成功** 
    
             redisson.getConfig().toJSON().toString() 
    
    **结果** \{"singleServerConfig":\{"idleConnectionTimeout":10000,"pingTimeout":1000,"connectTimeout":10000,"timeout":3000,"retryAttempts":3,"retryInterval":1500,"reconnectionTimeout":3000,"failedAttempts":3,"subscriptionsPerConnection":5,"address":"redis://127.0.0.1:6379","subscriptionConnectionMinimumIdleSize":1,"subscriptionConnectionPoolSize":50,"connectionMinimumIdleSize":10,"connectionPoolSize":64,"database":0,"dnsMonitoring":false,"dnsMonitoringInterval":5000\},"threads":0,"nettyThreads":0,"codec":\{"class":"org.redisson.codec.JsonJacksonCodec"\},"codecProvider":\{"class":"org.redisson.codec.DefaultCodecProvider"\},"resolverProvider":\{"class":"org.redisson.liveobject.provider.DefaultResolverProvider"\},"redissonReferenceEnabled":true,"useLinuxNativeEpoll":false\}
    
    # 连接方式 #
    
             RedissonClient client = Redisson.create(config);
    
            RAtomicLong longObject = client.getAtomicLong('myLong');
    
             // 同步执行方式
    
              longObject.compareAndSet(3, 401);
    
             // 异步执行方式
    
              longObject.compareAndSetAsync(3, 401);
    
              RedissonReactiveClient client = Redisson.createReactive(config); RAtomicLongReactive longObject = client.getAtomicLong('myLong');
    
             // 异步流执行方式
    
             longObject.compareAndSet(3, 401);
    
    # 数据序列化 #
    
    　　![562629-20170424161659006-538431813.png][]
    
    # 集合数据分片 #
    
    在集群模式下，Redisson为单个Redis集合类型提供了自动分片的功能。
    
    在自动分片功能的帮助下，单个集合拆分以后均匀的分布在整个集群里，而不是被挤在单一一个节点里。
    
    Redisson通过自身的分片算法，将一个大集合拆分为若干个片段（**默认****231****个，分片数量范围是3 - 16834**），然后将拆分后的片段均匀的分布到集群里各个节点里，保证每个节点分配到的片段数量大体相同。比如在默认情况下231个片段分到含有4个主节点的集群里，每个主节点将会分配到大约57个片段，同样的道理如果有5个主节点，每个节点会分配到大约46个片段。
    
    目前支持的数据结构类型包括[Set][]和[Map][Set].
    
    # 分布式对象 #
    
    **通用对象桶（Object Bucket****）**
    
    **二进制流（Binary Stream****）**
    
    **地理空间对象桶（Geospatial Bucket****）**
    
    ** BitSet**
    
    **原子整长形（AtomicLong****）**
    
    **原子双精度浮点数（AtomicDouble****）**
    
    **话题（订阅分发）**
    
    **布隆过滤器（Bloom Filter****）**
    
    **基数估计算法（HyperLogLog****）**
    
    ## 示例 ##
    
            **通用桶对象** 
    
             RBucket<AnyObject> bucket = redisson.getBucket("anyObject"); bucket.set(new AnyObject(1)); 
    
             AnyObject obj = bucket.get();
    
             **原子整长型** 
    
             RAtomicLong atomicLong = redisson.getAtomicLong("myAtomicLong"); atomicLong.set(3);
    
             atomicLong.incrementAndGet();
    
             atomicLong.get(); 
    
    # 分布式集合 #
    
    **映射（Map****）**
    
    **多值映射（****Multimap****）**
    
    **集（Set****）**
    
    **有序集（SortedSet****）**
    
    **计分排序集（ScoredSortedSet****）**
    
    **字典排序集（LexSortedSet****）**
    
    **列表（List****）**
    
    **列队（Queue****）**
    
    **双端队列（Deque****）**
    
    **阻塞队列（Blocking Queue****）**
    
    **有界阻塞列队（Bounded Blocking Queue****）**
    
    ** ****阻塞双端列队（Blocking Deque****）**
    
    **阻塞公平列队（Blocking Fair Queue****）**
    
    **延迟列队（Delayed Queue****）**
    
    ** ****优先队列（Priority Queue****）** 
    
    **优先双端队列（Priority Deque****）**
    
    分布式集合
    
    ## **示例**  ##
    
    **         Map**
    
             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");
    
    **         Set**
    
    **        ** RSet<SomeObject> set = redisson.getSet("anySet");
    
             set.add(new SomeObject());
    
             set.remove(new SomeObject());
    
    # 分布式锁 #
    
    **可重入锁（Reentrant Lock****）**
    
    **公平锁（Fair Lock****）**
    
    **联锁（MultiLock****）**
    
    **红锁（RedLock****）**
    
    **读写锁（ReadWriteLock****）**
    
    **信号量（Semaphore****）**
    
    **可过期性信号量（PermitExpirableSemaphore****）**
    
    **闭锁（CountDownLatch****）**
    
    ## **示例** ##
    
             RLock lock = redisson.getLock("anyLock");
    
             // 最常见的使用方法
    
              lock.lock();
    
             // 支持过期解锁功能 10秒钟以后自动解锁
    
              // 无需调用unlock方法手动解锁
    
             lock.lock(10, TimeUnit.SECONDS);
    
             // 尝试加锁，最多等待100秒，上锁以后10秒自动解锁 boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS); lock.unlock();
    
    # 分布式服务 #
    
    **分布式远程服务（Remote Service****）**
    
    **分布式实时对象（Live Object****）服务**
    
    **分布式执行服务（Executor Service****）**
    
    **分布式调度任务服务（Scheduler Service****）**
    
    **分布式映射归纳服务（MapReduce****）**
    
     
    
    **服务端（远端）实例** 
    
    RRemoteService remoteService = redisson.getRemoteService(); 
    
    SomeServiceImpl someServiceImpl = new SomeServiceImpl();
    
     // 在调用远程方法以前，应该首先注册远程服务 
    
     // 只注册了一个服务端工作者实例，只能同时执行一个并发调用
    
     remoteService.register(SomeServiceInterface.class, someServiceImpl);
    
     // 注册了12个服务端工作者实例，可以同时执行12个并发调用 
    
    remoteService.register(SomeServiceInterface.class, someServiceImpl, 12);
    
    **客户端（本地）实例** 
    
             RRemoteService remoteService = redisson.getRemoteService(); 
    
             SomeServiceInterface service = remoteService.get(SomeServiceInterface.class); 
    
             String result = service.doSomeStuff(1L, "secondParam", new AnyParam());
    
    # 独立节点模式 #
    
    Redisson Node指的是Redisson在分布式运算环境中作为独立节点运行的一种模式。Redisson Node的功能可以用来执行通过[分布式执行服务][Link 1]或[分布式调度执行服务][Link 1]发送的远程任务，也可以用来为[分布式远程服务][Link 1]提供远端服务。 
    
    依赖redisson-all.jar 
    
    独立节点模式-配置
    
    // Redisson程序化配置代码 
    
    Config config = ...
    
     // Redisson Node 程序化配置方法 
    
    RedissonNodeConfig nodeConfig = new RedissonNodeConfig(config); 
    
    Map<String, Integer> workers = new HashMap<String, Integer>(); 
    
    workers.put("test", 1); 
    
    nodeConfig.setExecutorServiceWorkers(workers); 
    
    // 创建一个Redisson Node实例 
    
    RedissonNode node = RedissonNode.create(nodeConfig); 
    
    // 或者通过指定的Redisson实例创建Redisson Node实例 
    
    RedissonNode node = RedissonNode.create(nodeConfig, redisson); 
    
    node.start(); 
    
    node.shutdown(); 
    
    # 三方框架整合 #
    
    **Spring****框架整合**
    
    **Spring Cache****整合**
    
    **Hibernate****整合**
    
    ** Tomcat****会话管理器（Tomcat Session Manager****）**
    
    **Spring Session****会话管理器**
    
    ## 三方框架-Spring整合 ##
    
    基本配置： 
    
    <redisson:client id="myRedisson"> <redisson:single-server address="127.0.0.1:6379"/> </redisson:client>
    
    完全配置： 
    
                       参照附件：Redisson说明文档.pdf
    
     *   *  三方框架-Spring调用
    
             
    
             @Service  
     public class RedissonUtils2 implements InitializingBean \{   
         @Autowired  
         private RedissonClient redissonClient;  
      
      
         public void afterPropertiesSet() throws Exception \{   
             Redisson redisson= (Redisson) redissonClient;  
            RAtomicDouble dd= redissonClient.getAtomicDouble("tt");  
            dd.set(1.22);  
             System.*out*.println("bean初始化后置方法"+redisson.getConfig().toJSON().toString());  
         \}  
     \} 
    
    # 总结 #
    
                       Redisson是redis分布式方向落地的产品，不仅开源免费，而且内置分布式锁，分布式服务等诸多功能，是基于redis实现分布式的最佳选择。

[Redisson]: https://redisson.org/
[Redis]: http://redis.cn/
[562629-20170424160738475-283091523.png]: /images/20220615/bf6893bf19e74bb9b6abc379cb2dfe49.png
[562629-20170424161659006-538431813.png]: /images/20220615/d2e3251c3ba9489382cee036fc00ba29.png
[Set]: https://github.com/redisson/redisson/wiki/7.-%E5%88%86%E5%B8%83%E5%BC%8F%E9%9B%86%E5%90%88
[Link 1]: https://github.com/redisson/redisson/wiki/9.-%E5%88%86%E5%B8%83%E5%BC%8F%E6%9C%8D%E5%8A%A1