redis整合spring(redisTemplate工具类)


前言

关于哨兵模式的配置,我是参考网上的,只是把配置拿到了这里,本人并没有亲测是否有效,代码是注释掉的,需要配置哨兵模式的,可以参考一下。

完整项目下载:
在测试包下有一个TestRedis.java这个类,可以使用这个类main方法测试

maven依赖

[html] view plain copy
  1. <!-- Redis客户端 -->    
  2. <dependency>    
  3.     <groupId>redis.clients</groupId>     
  4.     <artifactId>jedis</artifactId>    
  5.     <version>2.9.0</version>    
  6. </dependency>    
  7. <!-- redis Spring 基于注解配置 -->     
  8. <dependency>      
  9.   <groupId>org.springframework.data</groupId>      
  10.   <artifactId>spring-data-redis</artifactId>      
  11.   <version>1.7.2.RELEASE</version>      
  12. </dependency>   

redis.properties

[ruby] view plain copy
  1. #ip地址  
  2. redis.hostName=172.20.1.205  
  3. #端口号  
  4. redis.port=6379  
  5. #如果有密码  
  6. redis.password=123456  
  7. #客户端超时时间单位是毫秒 默认是2000  
  8. redis.timeout=10000  
  9.   
  10.   
  11. #最大空闲数  
  12. redis.maxIdle=300  
  13. #连接池的最大数据库连接数。设为0表示无限制,如果是jedis 2.4以后用redis.maxTotal  
  14. #redis.maxActive=600  
  15. #控制一个pool可分配多少个jedis实例,用来替换上面的redis.maxActive,如果是jedis 2.4以后用该属性  
  16. redis.maxTotal=1000  
  17. #最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。  
  18. redis.maxWaitMillis=1000  
  19. #连接的最小空闲时间 默认1800000毫秒(30分钟)  
  20. redis.minEvictableIdleTimeMillis=300000  
  21. #每次释放连接的最大数目,默认3  
  22. redis.numTestsPerEvictionRun=1024  
  23. #逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1  
  24. redis.timeBetweenEvictionRunsMillis=30000  
  25. #是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个  
  26. redis.testOnBorrow=true  
  27. #在空闲时检查有效性, 默认false  
  28. redis.testWhileIdle=true  
  29.   
  30.   
  31. #redis.sentinel.host1=172.20.1.230  
  32. #redis.sentinel.port1=26379  
  33.   
  34.   
  35. #redis.sentinel.host2=172.20.1.231  
  36. #redis.sentinel.port2=26379  
  37.   
  38.   
  39. #redis.sentinel.host3=172.20.1.232  
  40. #redis.sentinel.port3=26379  

applicationContext-redis.xml

[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" xmlns:p="http://www.springframework.org/schema/p"      
  4.     xmlns:context="http://www.springframework.org/schema/context"      
  5.     xmlns:mvc="http://www.springframework.org/schema/mvc"      
  6.     xmlns:cache="http://www.springframework.org/schema/cache"    
  7.     xsi:schemaLocation="http://www.springframework.org/schema/beans        
  8.                         http://www.springframework.org/schema/beans/spring-beans-4.2.xsd        
  9.                         http://www.springframework.org/schema/context        
  10.                         http://www.springframework.org/schema/context/spring-context-4.2.xsd        
  11.                         http://www.springframework.org/schema/mvc        
  12.                         http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd    
  13.                         http://www.springframework.org/schema/cache     
  14.                         http://www.springframework.org/schema/cache/spring-cache-4.2.xsd">  
  15.   
  16.   
  17.       
  18.     <!-- 加载配置文件 -->  
  19.     <context:property-placeholder location="classpath:properties/*.properties" />  
  20.     <!-- redis连接池配置-->    
  21.     <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig" >    
  22.         <!--最大空闲数-->    
  23.         <property name="maxIdle" value="${redis.maxIdle}" />    
  24.         <!--连接池的最大数据库连接数  -->  
  25.         <property name="maxTotal" value="${redis.maxTotal}" />  
  26.         <!--最大建立连接等待时间-->    
  27.         <property name="maxWaitMillis" value="${redis.maxWaitMillis}" />    
  28.         <!--逐出连接的最小空闲时间 默认1800000毫秒(30分钟)-->  
  29.         <property name="minEvictableIdleTimeMillis" value="${redis.minEvictableIdleTimeMillis}" />   
  30.         <!--每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3-->  
  31.         <property name="numTestsPerEvictionRun" value="${redis.numTestsPerEvictionRun}" />   
  32.         <!--逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1-->  
  33.         <property name="timeBetweenEvictionRunsMillis" value="${redis.timeBetweenEvictionRunsMillis}" />   
  34.         <!--是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个-->    
  35.         <property name="testOnBorrow" value="${redis.testOnBorrow}" />    
  36.         <!--在空闲时检查有效性, 默认false  -->  
  37.         <property name="testWhileIdle" value="${redis.testWhileIdle}" />    
  38.     </bean >  
  39.       
  40.       
  41.     <!-- redis集群配置 哨兵模式 -->  
  42.     <!-- <bean id="sentinelConfiguration" class="org.springframework.data.redis.connection.RedisSentinelConfiguration">  
  43.         <property name="master">  
  44.             <bean class="org.springframework.data.redis.connection.RedisNode">  
  45.                 这个值要和Sentinel中指定的master的值一致,不然启动时找不到Sentinel会报错的  
  46.                 <property name="name" value="mymaster"></property>  
  47.             </bean>  
  48.         </property>  
  49.         记住了,这里是指定Sentinel的IP和端口,不是Master和Slave的  
  50.         <property name="sentinels">  
  51.             <set>  
  52.                 <bean class="org.springframework.data.redis.connection.RedisNode">  
  53.                     <constructor-arg name="host" value="${redis.sentinel.host1}"></constructor-arg>  
  54.                     <constructor-arg name="port" value="${redis.sentinel.port1}"></constructor-arg>  
  55.                 </bean>  
  56.                 <bean class="org.springframework.data.redis.connection.RedisNode">  
  57.                     <constructor-arg name="host" value="${redis.sentinel.host2}"></constructor-arg>  
  58.                     <constructor-arg name="port" value="${redis.sentinel.port2}"></constructor-arg>  
  59.                 </bean>  
  60.                 <bean class="org.springframework.data.redis.connection.RedisNode">  
  61.                     <constructor-arg name="host" value="${redis.sentinel.host3}"></constructor-arg>  
  62.                     <constructor-arg name="port" value="${redis.sentinel.port3}"></constructor-arg>  
  63.                 </bean>  
  64.             </set>  
  65.         </property>  
  66.     </bean>  
  67.     <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">  
  68.         <constructor-arg name="sentinelConfig" ref="sentinelConfiguration"></constructor-arg>  
  69.         <constructor-arg name="poolConfig" ref="jedisPoolConfig"></constructor-arg>  
  70.     </bean> -->  
  71.       
  72.     <!--redis连接工厂 -->  
  73.     <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" destroy-method="destroy">   
  74.         <property name="poolConfig" ref="jedisPoolConfig"></property>   
  75.         <!--IP地址 -->  
  76.         <property name="hostName" value="${redis.hostName}"></property>   
  77.         <!--端口号  -->  
  78.         <property name="port" value="${redis.port}"></property>   
  79.         <!--如果Redis设置有密码  -->  
  80.         <property name="password" value="${redis.password}" />  
  81.         <!--客户端超时时间单位是毫秒  -->  
  82.         <property name="timeout" value="${redis.timeout}"></property>   
  83.     </bean>    
  84.       
  85.     <!--redis操作模版,使用该对象可以操作redis  -->  
  86.     <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate" >    
  87.         <property name="connectionFactory" ref="jedisConnectionFactory" />    
  88.         <!--如果不配置Serializer,那么存储的时候缺省使用String,如果用User类型存储,那么会提示错误User can't cast to String!!  -->    
  89.         <property name="keySerializer" >    
  90.             <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />    
  91.         </property>    
  92.         <property name="valueSerializer" >    
  93.             <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer" />    
  94.         </property>    
  95.         <property name="hashKeySerializer">    
  96.             <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>    
  97.         </property>    
  98.         <property name="hashValueSerializer">    
  99.             <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/>    
  100.         </property>    
  101.         <!--开启事务  -->  
  102.         <property name="enableTransactionSupport" value="true"></property>  
  103.     </bean >    
  104.       
  105.     <!--自定义redis工具类,在需要缓存的地方注入此类  -->  
  106.     <bean id="redisUtil" class="com.ryx.global.util.RedisUtil">  
  107.         <property name="redisTemplate" ref="redisTemplate" />  
  108.     </bean>  
  109.       
  110. </beans>  

RedisUtil.java

[java] view plain copy
  1. package com.ryx.global.util;  
  2.   
  3.   
  4. import java.util.List;  
  5. import java.util.Map;  
  6. import java.util.Set;  
  7. import java.util.concurrent.TimeUnit;  
  8.   
  9.   
  10. import org.springframework.data.redis.core.RedisTemplate;  
  11. import org.springframework.util.CollectionUtils;  
  12.   
  13.   
  14. /** 
  15.  *  
  16.  * @author 王赛超 
  17.  * 基于spring和redis的redisTemplate工具类 
  18.  * 针对所有的hash 都是以h开头的方法 
  19.  * 针对所有的Set 都是以s开头的方法                    不含通用方法 
  20.  * 针对所有的List 都是以l开头的方法 
  21.  */  
  22. public class RedisUtil {  
  23.   
  24.   
  25.     private RedisTemplate<String, Object> redisTemplate;  
  26.       
  27.     public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {  
  28.         this.redisTemplate = redisTemplate;  
  29.     }  
  30.     //=============================common============================  
  31.     /** 
  32.      * 指定缓存失效时间 
  33.      * @param key 键 
  34.      * @param time 时间(秒) 
  35.      * @return 
  36.      */  
  37.     public boolean expire(String key,long time){  
  38.         try {  
  39.             if(time>0){  
  40.                 redisTemplate.expire(key, time, TimeUnit.SECONDS);  
  41.             }  
  42.             return true;  
  43.         } catch (Exception e) {  
  44.             e.printStackTrace();  
  45.             return false;  
  46.         }  
  47.     }  
  48.       
  49.     /** 
  50.      * 根据key 获取过期时间 
  51.      * @param key 键 不能为null 
  52.      * @return 时间(秒) 返回0代表为永久有效 
  53.      */  
  54.     public long getExpire(String key){  
  55.         return redisTemplate.getExpire(key,TimeUnit.SECONDS);  
  56.     }  
  57.       
  58.     /** 
  59.      * 判断key是否存在 
  60.      * @param key 键 
  61.      * @return true 存在 false不存在 
  62.      */  
  63.     public boolean hasKey(String key){  
  64.         try {  
  65.             return redisTemplate.hasKey(key);  
  66.         } catch (Exception e) {  
  67.             e.printStackTrace();  
  68.             return false;  
  69.         }  
  70.     }  
  71.       
  72.     /** 
  73.      * 删除缓存 
  74.      * @param key 可以传一个值 或多个 
  75.      */  
  76.     @SuppressWarnings("unchecked")  
  77.     public void del(String ... key){  
  78.         if(key!=null&&key.length>0){  
  79.             if(key.length==1){  
  80.                 redisTemplate.delete(key[0]);  
  81.             }else{  
  82.                 redisTemplate.delete(CollectionUtils.arrayToList(key));  
  83.             }  
  84.         }  
  85.     }  
  86.       
  87.     //============================String=============================  
  88.     /** 
  89.      * 普通缓存获取 
  90.      * @param key 键 
  91.      * @return 值 
  92.      */  
  93.     public Object get(String key){  
  94.         return key==null?null:redisTemplate.opsForValue().get(key);  
  95.     }  
  96.       
  97.     /** 
  98.      * 普通缓存放入 
  99.      * @param key 键 
  100.      * @param value 值 
  101.      * @return true成功 false失败 
  102.      */  
  103.     public boolean set(String key,Object value) {  
  104.          try {  
  105.             redisTemplate.opsForValue().set(key, value);  
  106.             return true;  
  107.         } catch (Exception e) {  
  108.             e.printStackTrace();  
  109.             return false;  
  110.         }  
  111.           
  112.     }  
  113.       
  114.     /** 
  115.      * 普通缓存放入并设置时间 
  116.      * @param key 键 
  117.      * @param value 值 
  118.      * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期 
  119.      * @return true成功 false 失败 
  120.      */  
  121.     public boolean set(String key,Object value,long time){  
  122.         try {  
  123.             if(time>0){  
  124.                 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);  
  125.             }else{  
  126.                 set(key, value);  
  127.             }  
  128.             return true;  
  129.         } catch (Exception e) {  
  130.             e.printStackTrace();  
  131.             return false;  
  132.         }  
  133.     }  
  134.       
  135.     /** 
  136.      * 递增 
  137.      * @param key 键 
  138.      * @param by 要增加几(大于0) 
  139.      * @return 
  140.      */  
  141.     public long incr(String key, long delta){    
  142.         if(delta<0){  
  143.             throw new RuntimeException("递增因子必须大于0");  
  144.         }  
  145.         return redisTemplate.opsForValue().increment(key, delta);  
  146.     }  
  147.       
  148.     /** 
  149.      * 递减 
  150.      * @param key 键 
  151.      * @param by 要减少几(小于0) 
  152.      * @return 
  153.      */  
  154.     public long decr(String key, long delta){    
  155.         if(delta<0){  
  156.             throw new RuntimeException("递减因子必须大于0");  
  157.         }  
  158.         return redisTemplate.opsForValue().increment(key, -delta);    
  159.     }    
  160.       
  161.     //================================Map=================================  
  162.     /** 
  163.      * HashGet 
  164.      * @param key 键 不能为null 
  165.      * @param item 项 不能为null 
  166.      * @return 值 
  167.      */  
  168.     public Object hget(String key,String item){  
  169.         return redisTemplate.opsForHash().get(key, item);  
  170.     }  
  171.       
  172.     /** 
  173.      * 获取hashKey对应的所有键值 
  174.      * @param key 键 
  175.      * @return 对应的多个键值 
  176.      */  
  177.     public Map<Object,Object> hmget(String key){  
  178.         return redisTemplate.opsForHash().entries(key);  
  179.     }  
  180.       
  181.     /** 
  182.      * HashSet 
  183.      * @param key 键 
  184.      * @param map 对应多个键值 
  185.      * @return true 成功 false 失败 
  186.      */  
  187.     public boolean hmset(String key, Map<String,Object> map){    
  188.         try {  
  189.             redisTemplate.opsForHash().putAll(key, map);  
  190.             return true;  
  191.         } catch (Exception e) {  
  192.             e.printStackTrace();  
  193.             return false;  
  194.         }  
  195.     }  
  196.       
  197.     /** 
  198.      * HashSet 并设置时间 
  199.      * @param key 键 
  200.      * @param map 对应多个键值 
  201.      * @param time 时间(秒) 
  202.      * @return true成功 false失败 
  203.      */  
  204.     public boolean hmset(String key, Map<String,Object> map, long time){    
  205.         try {  
  206.             redisTemplate.opsForHash().putAll(key, map);  
  207.             if(time>0){  
  208.                 expire(key, time);  
  209.             }  
  210.             return true;  
  211.         } catch (Exception e) {  
  212.             e.printStackTrace();  
  213.             return false;  
  214.         }  
  215.     }  
  216.       
  217.     /** 
  218.      * 向一张hash表中放入数据,如果不存在将创建 
  219.      * @param key 键 
  220.      * @param item 项 
  221.      * @param value 值 
  222.      * @return true 成功 false失败 
  223.      */  
  224.     public boolean hset(String key,String item,Object value) {  
  225.          try {  
  226.             redisTemplate.opsForHash().put(key, item, value);  
  227.             return true;  
  228.         } catch (Exception e) {  
  229.             e.printStackTrace();  
  230.             return false;  
  231.         }  
  232.     }  
  233.       
  234.     /** 
  235.      * 向一张hash表中放入数据,如果不存在将创建 
  236.      * @param key 键 
  237.      * @param item 项 
  238.      * @param value 值 
  239.      * @param time 时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间 
  240.      * @return true 成功 false失败 
  241.      */  
  242.     public boolean hset(String key,String item,Object value,long time) {  
  243.          try {  
  244.             redisTemplate.opsForHash().put(key, item, value);  
  245.             if(time>0){  
  246.                 expire(key, time);  
  247.             }  
  248.             return true;  
  249.         } catch (Exception e) {  
  250.             e.printStackTrace();  
  251.             return false;  
  252.         }  
  253.     }  
  254.       
  255.     /** 
  256.      * 删除hash表中的值 
  257.      * @param key 键 不能为null 
  258.      * @param item 项 可以使多个 不能为null 
  259.      */  
  260.     public void hdel(String key, Object... item){    
  261.         redisTemplate.opsForHash().delete(key,item);  
  262.     }   
  263.       
  264.     /** 
  265.      * 判断hash表中是否有该项的值 
  266.      * @param key 键 不能为null 
  267.      * @param item 项 不能为null 
  268.      * @return true 存在 false不存在 
  269.      */  
  270.     public boolean hHasKey(String key, String item){  
  271.         return redisTemplate.opsForHash().hasKey(key, item);  
  272.     }   
  273.       
  274.     /** 
  275.      * hash递增 如果不存在,就会创建一个 并把新增后的值返回 
  276.      * @param key 键 
  277.      * @param item 项 
  278.      * @param by 要增加几(大于0) 
  279.      * @return 
  280.      */  
  281.     public double hincr(String key, String item,double by){    
  282.         return redisTemplate.opsForHash().increment(key, item, by);  
  283.     }  
  284.       
  285.     /** 
  286.      * hash递减 
  287.      * @param key 键 
  288.      * @param item 项 
  289.      * @param by 要减少记(小于0) 
  290.      * @return 
  291.      */  
  292.     public double hdecr(String key, String item,double by){    
  293.         return redisTemplate.opsForHash().increment(key, item,-by);    
  294.     }    
  295.       
  296.     //============================set=============================  
  297.     /** 
  298.      * 根据key获取Set中的所有值 
  299.      * @param key 键 
  300.      * @return 
  301.      */  
  302.     public Set<Object> sGet(String key){  
  303.         try {  
  304.             return redisTemplate.opsForSet().members(key);  
  305.         } catch (Exception e) {  
  306.             e.printStackTrace();  
  307.             return null;  
  308.         }  
  309.     }  
  310.       
  311.     /** 
  312.      * 根据value从一个set中查询,是否存在 
  313.      * @param key 键 
  314.      * @param value 值 
  315.      * @return true 存在 false不存在 
  316.      */  
  317.     public boolean sHasKey(String key,Object value){  
  318.         try {  
  319.             return redisTemplate.opsForSet().isMember(key, value);  
  320.         } catch (Exception e) {  
  321.             e.printStackTrace();  
  322.             return false;  
  323.         }  
  324.     }  
  325.       
  326.     /** 
  327.      * 将数据放入set缓存 
  328.      * @param key 键 
  329.      * @param values 值 可以是多个 
  330.      * @return 成功个数 
  331.      */  
  332.     public long sSet(String key, Object...values) {  
  333.         try {  
  334.             return redisTemplate.opsForSet().add(key, values);  
  335.         } catch (Exception e) {  
  336.             e.printStackTrace();  
  337.             return 0;  
  338.         }  
  339.     }  
  340.       
  341.     /** 
  342.      * 将set数据放入缓存 
  343.      * @param key 键 
  344.      * @param time 时间(秒) 
  345.      * @param values 值 可以是多个 
  346.      * @return 成功个数 
  347.      */  
  348.     public long sSetAndTime(String key,long time,Object...values) {  
  349.         try {  
  350.             Long count = redisTemplate.opsForSet().add(key, values);  
  351.             if(time>0) expire(key, time);  
  352.             return count;  
  353.         } catch (Exception e) {  
  354.             e.printStackTrace();  
  355.             return 0;  
  356.         }  
  357.     }  
  358.       
  359.     /** 
  360.      * 获取set缓存的长度 
  361.      * @param key 键 
  362.      * @return 
  363.      */  
  364.     public long sGetSetSize(String key){  
  365.         try {  
  366.             return redisTemplate.opsForSet().size(key);  
  367.         } catch (Exception e) {  
  368.             e.printStackTrace();  
  369.             return 0;  
  370.         }  
  371.     }  
  372.       
  373.     /** 
  374.      * 移除值为value的 
  375.      * @param key 键 
  376.      * @param values 值 可以是多个 
  377.      * @return 移除的个数 
  378.      */  
  379.     public long setRemove(String key, Object ...values) {  
  380.         try {  
  381.             Long count = redisTemplate.opsForSet().remove(key, values);  
  382.             return count;  
  383.         } catch (Exception e) {  
  384.             e.printStackTrace();  
  385.             return 0;  
  386.         }  
  387.     }  
  388.     //===============================list=================================  
  389.       
  390.     /** 
  391.      * 获取list缓存的内容 
  392.      * @param key 键 
  393.      * @param start 开始 
  394.      * @param end 结束  0 到 -1代表所有值 
  395.      * @return 
  396.      */  
  397.     public List<Object> lGet(String key,long start, long end){  
  398.         try {  
  399.             return redisTemplate.opsForList().range(key, start, end);  
  400.         } catch (Exception e) {  
  401.             e.printStackTrace();  
  402.             return null;  
  403.         }  
  404.     }  
  405.       
  406.     /** 
  407.      * 获取list缓存的长度 
  408.      * @param key 键 
  409.      * @return 
  410.      */  
  411.     public long lGetListSize(String key){  
  412.         try {  
  413.             return redisTemplate.opsForList().size(key);  
  414.         } catch (Exception e) {  
  415.             e.printStackTrace();  
  416.             return 0;  
  417.         }  
  418.     }  
  419.       
  420.     /** 
  421.      * 通过索引 获取list中的值 
  422.      * @param key 键 
  423.      * @param index 索引  index>=0时, 0 表头,1 第二个元素,依次类推;index<0时,-1,表尾,-2倒数第二个元素,依次类推 
  424.      * @return 
  425.      */  
  426.     public Object lGetIndex(String key,long index){  
  427.         try {  
  428.             return redisTemplate.opsForList().index(key, index);  
  429.         } catch (Exception e) {  
  430.             e.printStackTrace();  
  431.             return null;  
  432.         }  
  433.     }  
  434.       
  435.     /** 
  436.      * 将list放入缓存 
  437.      * @param key 键 
  438.      * @param value 值 
  439.      * @param time 时间(秒) 
  440.      * @return 
  441.      */  
  442.     public boolean lSet(String key, Object value) {  
  443.         try {  
  444.             redisTemplate.opsForList().rightPush(key, value);  
  445.             return true;  
  446.         } catch (Exception e) {  
  447.             e.printStackTrace();  
  448.             return false;  
  449.         }  
  450.     }  
  451.       
  452.     /** 
  453.      * 将list放入缓存 
  454.      * @param key 键 
  455.      * @param value 值 
  456.      * @param time 时间(秒) 
  457.      * @return 
  458.      */  
  459.     public boolean lSet(String key, Object value, long time) {  
  460.         try {  
  461.             redisTemplate.opsForList().rightPush(key, value);  
  462.             if (time > 0) expire(key, time);  
  463.             return true;  
  464.         } catch (Exception e) {  
  465.             e.printStackTrace();  
  466.             return false;  
  467.         }  
  468.     }  
  469.       
  470.     /** 
  471.      * 将list放入缓存 
  472.      * @param key 键 
  473.      * @param value 值 
  474.      * @param time 时间(秒) 
  475.      * @return 
  476.      */  
  477.     public boolean lSet(String key, List<Object> value) {  
  478.         try {  
  479.             redisTemplate.opsForList().rightPushAll(key, value);  
  480.             return true;  
  481.         } catch (Exception e) {  
  482.             e.printStackTrace();  
  483.             return false;  
  484.         }  
  485.     }  
  486.       
  487.     /** 
  488.      * 将list放入缓存 
  489.      * @param key 键 
  490.      * @param value 值 
  491.      * @param time 时间(秒) 
  492.      * @return 
  493.      */  
  494.     public boolean lSet(String key, List<Object> value, long time) {  
  495.         try {  
  496.             redisTemplate.opsForList().rightPushAll(key, value);  
  497.             if (time > 0) expire(key, time);  
  498.             return true;  
  499.         } catch (Exception e) {  
  500.             e.printStackTrace();  
  501.             return false;  
  502.         }  
  503.     }  
  504.       
  505.     /** 
  506.      * 根据索引修改list中的某条数据 
  507.      * @param key 键 
  508.      * @param index 索引 
  509.      * @param value 值 
  510.      * @return 
  511.      */  
  512.     public boolean lUpdateIndex(String key, long index,Object value) {  
  513.         try {  
  514.             redisTemplate.opsForList().set(key, index, value);  
  515.             return true;  
  516.         } catch (Exception e) {  
  517.             e.printStackTrace();  
  518.             return false;  
  519.         }  
  520.     }   
  521.       
  522.     /** 
  523.      * 移除N个值为value  
  524.      * @param key 键 
  525.      * @param count 移除多少个 
  526.      * @param value 值 
  527.      * @return 移除的个数 
  528.      */  
  529.     public long lRemove(String key,long count,Object value) {  
  530.         try {  
  531.             Long remove = redisTemplate.opsForList().remove(key, count, value);  
  532.             return remove;  
  533.         } catch (Exception e) {  
  534.             e.printStackTrace();  
  535.             return 0;  
  536.         }  
  537.     }  
  538.       
  539. }  

TestRedis.java

[java] view plain copy
  1. package com.ryx.test;  
  2.   
  3.   
  4. import java.util.ArrayList;  
  5. import java.util.HashMap;  
  6. import java.util.List;  
  7. import java.util.Map;  
  8.   
  9.   
  10. import org.springframework.context.ApplicationContext;  
  11. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  12.   
  13.   
  14. import com.ryx.global.util.RedisUtil;  
  15.   
  16.   
  17. public class TestRedis {  
  18.       
  19.     public static void main(String[] args) throws Exception {  
  20.         @SuppressWarnings("resource")  
  21.         ApplicationContext context=new ClassPathXmlApplicationContext("classpath:spring/applicationContext-redis.xml");  
  22.         RedisUtil redisUtil=(RedisUtil) context.getBean("redisUtil");  
  23.           
  24.         //=====================testString======================  
  25.         //redisUtil.set("name", "王赛超");  
  26.         //redisUtil.set("age", 24);  
  27.         //redisUtil.set("address", "河北邯郸");  
  28.           
  29.         //System.out.println(redisUtil.set("address", "河北邯郸", 50));  
  30.           
  31.         //System.out.println(redisUtil.get("age"));  
  32.           
  33.           
  34.         //redisUtil.set("age", 1000);  
  35.           
  36.         //Object object = redisUtil.get("user2");  
  37.           
  38.         //System.out.println(object);  
  39.           
  40.         //redisUtil.del("address");  
  41.         //redisUtil.set("class", 15);  
  42.         //long incr = redisUtil.incr("a", 1);  
  43.         //System.out.println(incr);  
  44.           
  45.         //Thread.sleep(5000);  
  46.         /*Map<String,Object> map=new HashMap<>(); 
  47.         map.put("name", "王赛超"); 
  48.         map.put("age", 24); 
  49.         map.put("address", "河北邯郸666"); 
  50.         redisUtil.hmset("15532002725", map,1000);*/  
  51.           
  52.         //redisUtil.del("15532002725");  
  53.         //redisUtil.hset("15532002725","address","河北邯郸",1000);  
  54.         //redisUtil.hdel("15532002725", "name");  
  55.         //System.out.println(redisUtil.sSetAndTime("15532002727",1000,"haha"));  
  56.         //System.out.println(redisUtil.sGet("15532002727"));  
  57.         //System.out.println(redisUtil.sHasKey("15532002727","name"));  
  58.         System.out.println(redisUtil.lRemove("15532002728",1,2));  
  59.         System.out.println(redisUtil.lGet("15532002728",0,-1));  
  60.         System.out.println(redisUtil.lGetListSize("15532002728"));  
  61.         System.out.println(redisUtil.lGetIndex("15532002728",1));  
  62.           
  63.           
  64.         //System.out.println(redisUtil.getExpire("15532002725"));  
  65.           
  66.         //System.out.println(redisUtil.hget("15532002725","name"));  
  67.         //System.out.println(redisUtil.hmget("15532002725"));  
  68.           
  69.     }  
  70.       
  71.       
  72.       
  73. }  
  74. class User{  
  75.     private String name;  
  76.     private Integer age;  
  77.     private String address;  
  78.     private Double classz;  
  79.     private Float classz2;  
  80.     public User() {  
  81.         super();  
  82.     }  
  83.     public User(String name, Integer age, String address, Double classz,  
  84.             Float classz2) {  
  85.         super();  
  86.         this.name = name;  
  87.         this.age = age;  
  88.         this.address = address;  
  89.         this.classz = classz;  
  90.         this.classz2 = classz2;  
  91.     }  
  92.     public String getName() {  
  93.         return name;  
  94.     }  
  95.     public void setName(String name) {  
  96.         this.name = name;  
  97.     }  
  98.     public Integer getAge() {  
  99.         return age;  
  100.     }  
  101.     public void setAge(Integer age) {  
  102.         this.age = age;  
  103.     }  
  104.     public String getAddress() {  
  105.         return address;  
  106.     }  
  107.     public void setAddress(String address) {  
  108.         this.address = address;  
  109.     }  
  110.     public Double getClassz() {  
  111.         return classz;  
  112.     }  
  113.     public void setClassz(Double classz) {  
  114.         this.classz = classz;  
  115.     }  
  116.     public Float getClassz2() {  
  117.         return classz2;  
  118.     }  
  119.     public void setClassz2(Float classz2) {  
  120.         this.classz2 = classz2;  
  121.     }  
  122. }  
原文地址,转载请注明出处:http://blog.csdn.net/qq_34021712/article/details/75949706   ©王赛超
阅读更多

没有更多推荐了,返回首页