redisson整合spring

原文：http://blog.csdn.net/wang_keng/article/details/73549274

 

首先讲下什么是Redisson：Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。（摘自redisson的wiki：wiki地址）

redisson提供的api均以面向对象的操作方式，将key-value封装成我们熟悉的集合或者对象，我们可以通过封装的api更方便的操作数据。同时它提供了多个实现了java.util.corrurnent接口的集合类，让我们能在线程安全的环境下操作数据。

其中redis的官网也将它纳入推荐使用的工具中，可见redisson已经逐渐上位。

 

废话不多说，现在开始讲下怎么整合redisson到spring：

首先引入redisson的包：（如果你还在用手动加jar包的方式，那建议你赶紧学一下maven，用上后会让你有种便秘一星期后突然通便的清爽）

[html] view plain copy
 
  1. <dependency>   
  2. <groupId>org.redisson</groupId>  
  3. <artifactId>redisson</artifactId>  
  4.   <version>2.8.2</version>   
  5. </dependency>  </span>  

接下来新建redisson.xml文件：（可参考wiki：redisson配置教程）

 

[html] view plain copy
 
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.        xmlns:context="http://www.springframework.org/schema/context"  
  5.        xmlns:redisson="http://redisson.org/schema/redisson"  
  6.        xsi:schemaLocation="http://www.springframework.org/schema/beans  
  7.        http://www.springframework.org/schema/beans/spring-beans.xsd  
  8.        http://www.springframework.org/schema/context  
  9.        http://www.springframework.org/schema/context/spring-context.xsd  
  10.        http://redisson.org/schema/redisson  
  11.        http://redisson.org/schema/redisson/redisson.xsd">  
  12.    <!--  
  13.         单台redis机器配置    
  14.     <redisson:client id="redissonClient">  
  15.         <redisson:single-server address="192.168.2.100:7000" connection-pool-size="30"/>  
  16.     </redisson:client>  
  17.      -->  
  18.      <!-- redis集群配置 -->  
  19.      <redisson:client id="redissonClient" >  
  20.           
  21.         <redisson:cluster-servers scan-interval="10000">   <!-- //scan-interval:集群状态扫描间隔时间，单位是毫秒 -->  
  22.             <redisson:node-address value="192.168.2.100:7000"></redisson:node-address>  
  23.             <redisson:node-address value="192.168.2.100:7001"></redisson:node-address>  
  24.             <redisson:node-address value="192.168.2.100:7002"></redisson:node-address>  
  25.             <redisson:node-address value="192.168.2.100:7003"></redisson:node-address>  
  26.             <redisson:node-address value="192.168.2.100:7004"></redisson:node-address>  
  27.             <redisson:node-address value="192.168.2.100:7005"></redisson:node-address>  
  28.         </redisson:cluster-servers>  
  29.           
  30.     </redisson:client>  
  31. </beans> 


然后在Application.xml中引入redisson.xml：<import resource="classpath:/spring/redisson.xml" />     （路径记得自己改哦~）

至此我们redisson的环境就配置好了。接下来就是怎么操作它来操作redis：

首先新建一个工具类RedissonUtils：

 

[java] view plain copy
 

package com.basic.common.utils.redis;  

  1. import java.util.Map;  
  2. import org.redisson.api.RAtomicLong;  
  3. import org.redisson.api.RBucket;  
  4. import org.redisson.api.RCountDownLatch;  
  5. import org.redisson.api.RDeque;  
  6. import org.redisson.api.RList;  
  7. import org.redisson.api.RLock;  
  8. import org.redisson.api.RMap;  
  9. import org.redisson.api.RQueue;  
  10. import org.redisson.api.RSet;  
  11. import org.redisson.api.RSortedSet;  
  12. import org.redisson.api.RTopic;  
  13. import org.redisson.api.RedissonClient;  
  14. import org.springframework.stereotype.Service;  
  15. import com.basic.common.utils.generator.CollectionObjectConvert;  
  16. @Service  
  17. public class RedissonUtils{  
  18. /**  
  19.      * 获取字符串对象  
  20.      * @param redisson  
  21.      * @param t  
  22.      * @param objectName  
  23.      * @return  
  24.      */    
  25. public static <T> RBucket<T> getRBucket(RedissonClient redissonClient,String objectName){    
  26.         RBucket<T> bucket=redissonClient.getBucket(objectName);    
  27. return bucket;    
  28.     }    
  29. /**  
  30.      * 获取Map对象  
  31.      * @param redisson  
  32.      * @param objectName  
  33.      * @return  
  34.      */    
  35. public static <K,V> RMap<K, V> getRMap(RedissonClient redissonClient,String objectName){    
  36.         RMap<K, V> map=redissonClient.getMap(objectName);    
  37. return map;    
  38.     }    
  39. /**  
  40.      * 获取有序集合  
  41.      * @param redisson  
  42.      * @param objectName  
  43.      * @return  
  44.      */    
  45. public static <V> RSortedSet<V> getRSortedSet(RedissonClient redissonClient,String objectName){    
  46.         RSortedSet<V> sortedSet=redissonClient.getSortedSet(objectName);    
  47. return sortedSet;    
  48.     }    
  49. /**  
  50.      * 获取集合  
  51.      * @param redisson  
  52.      * @param objectName  
  53.      * @return  
  54.      */    
  55. public static <V> RSet<V> getRSet(RedissonClient redissonClient,String objectName){    
  56.         RSet<V> rSet=redissonClient.getSet(objectName);    
  57. return rSet;    
  58.     }    
  59. /**  
  60.      * 获取列表  
  61.      * @param redisson  
  62.      * @param objectName  
  63.      * @return  
  64.      */    
  65. public static <V> RList<V> getRList(RedissonClient redissonClient,String objectName){    
  66.         RList<V> rList=redissonClient.getList(objectName);    
  67. return rList;    
  68.     }    
  69. /**  
  70.      * 获取队列  
  71.      * @param redisson  
  72.      * @param objectName  
  73.      * @return  
  74.      */    
  75. public static <V> RQueue<V> getRQueue(RedissonClient redissonClient,String objectName){    
  76.         RQueue<V> rQueue=redissonClient.getQueue(objectName);    
  77. return rQueue;    
  78.     }    
  79. /**  
  80.      * 获取双端队列  
  81.      * @param redisson  
  82.      * @param objectName  
  83.      * @return  
  84.      */    
  85. public static <V> RDeque<V> getRDeque(RedissonClient redissonClient,String objectName){    
  86.         RDeque<V> rDeque=redissonClient.getDeque(objectName);    
  87. return rDeque;    
  88.     }    
  89. /**  
  90.      * 此方法不可用在Redisson 1.2 中   
  91.      * 在1.2.2版本中 可用  
  92.      * @param redisson  
  93.      * @param objectName  
  94.      * @return  
  95.      */    
  96. /**  
  97.     public <V> RBlockingQueue<V> getRBlockingQueue(Redisson redisson,String objectName){  
  98.         RBlockingQueue rb=redisson.getBlockingQueue(objectName);  
  99.         return rb;  
  100.     }*/    
  101. /**  
  102.      * 获取锁  
  103.      * @param redisson  
  104.      * @param objectName  
  105.      * @return  
  106.      */    
  107. public static RLock getRLock(RedissonClient redissonClient,String objectName){    
  108.         RLock rLock=redissonClient.getLock(objectName);    
  109. return rLock;    
  110.     }    
  111. /**  
  112.      * 获取原子数  
  113.      * @param redisson  
  114.      * @param objectName  
  115.      * @return  
  116.      */    
  117. public static RAtomicLong getRAtomicLong(RedissonClient redissonClient,String objectName){    
  118.         RAtomicLong rAtomicLong=redissonClient.getAtomicLong(objectName);    
  119. return rAtomicLong;    
  120.     }    
  121. /**  
  122.      * 获取记数锁  
  123.      * @param redisson  
  124.      * @param objectName  
  125.      * @return  
  126.      */    
  127. public static RCountDownLatch getRCountDownLatch(RedissonClient redissonClient,String objectName){    
  128.         RCountDownLatch rCountDownLatch=redissonClient.getCountDownLatch(objectName);    
  129. return rCountDownLatch;    
  130.     }    
  131. /**  
  132.      * 获取消息的Topic  
  133.      * @param redisson  
  134.      * @param objectName  
  135.      * @return  
  136.      */    
  137. public static <M> RTopic<M> getRTopic(RedissonClient redissonClient,String objectName){    
  138.          RTopic<M> rTopic=redissonClient.getTopic(objectName);    
  139. return rTopic;    
  140.     }    
  141. }  
  142.  


然后我们需要在调用RedissonUtils的类中依赖进RedissonClient 

@Autowired  

private RedissonClient redisson;

只后便可以对redis进行操作啦

RMap<String, Object> map = RedissonUtils.getRMap(redisson,key);

map.put("key","value");     调用到这个语句的同时就已经对redis中的数据进行了修改。 

 

注意！redis最好是3.0以上的，官方发布的版本，不然会出现莫名其妙的错误

 

posted @ 2018-03-09 17:55  这个名字想了很久~  阅读(1366)  评论(1)  编辑  收藏  举报