devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

使用spring-data-redis进行对redis的操作，封装的一些操作方法_基于spring-data-redis3封装的

作者：我家自动化 | 2024-03-11 23:51:13

赞

踩

基于spring-data-redis3封装的

   这个算是工作笔记吧，因为是我的实际工作内容

   spring-data-redis api地址  http://docs.spring.io/spring-data/redis/docs/current/api/

   

  依赖maven包(当前spring-data-redis的最新版本是1.7.2.RELEASE， jedis的最新版本是2.9.0)：

spring-data-redis的maven仓库地址是: https://mvnrepository.com/artifact/org.springframework.data/spring-data-redis

jedis的maven仓库地址是: https://mvnrepository.com/artifact/redis.clients/jedis

 

  1. <!-- spring-data -->
  2. <dependency>
  3.    <groupId>org.springframework.data</groupId>
  4.    <artifactId>spring-data-redis</artifactId>
  5.    <version>1.6.4.RELEASE</version>
  6. </dependency>
  7.  
  8. <!-- redis客户端 -->
  9. <dependency>
  10.    <groupId>redis.clients</groupId>
  11.    <artifactId>jedis</artifactId>
  12.    <version>2.5.2</version>
  13. </dependency>

 

 

 

spring-data-redis的配置文件：

 

  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:util="http://www.springframework.org/schema/util"
  5.        xmlns:p="http://www.springframework.org/schema/p"
  6.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  7.          http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
  8.         
  9.     <util:properties id="redisProps" location="classpath:redis.properties"/>
  10.  
  11.     <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" id="stringRedisSerializer"/>
  12.  
  13.     <bean class="org.springframework.data.redis.serializer.JacksonJsonRedisSerializer" id="jacksonJsonRedisSerializer">
  14.         <constructor-arg type="java.lang.Class" value="java.lang.Object"/>
  15.     </bean>
  16.  
  17.     <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"
  18.           id="jdkSerializationRedisSerializer"/>
  19.  
  20. <!--     <bean class="org.codehaus.jackson.map.ObjectMapper" id="jackObjMapper"/> -->
  21.  
  22.     <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
  23.        <property name="maxTotal" value="#{redisProps['redis.pool.maxActive']}"/>
  24.         <property name="maxIdle" value="#{redisProps['redis.pool.maxIdle']}"/>
  25.         <property name="maxWaitMillis" value="#{redisProps['redis.pool.maxWait']}"/>
  26.         <property name="testOnBorrow" value="#{redisProps['redis.pool.testOnBorrow']}"/>
  27.     </bean>
  28.  
  29.     <bean id="redisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
  30.           p:hostName="#{redisProps['redis.ip']}" 
  31.           p:port="#{redisProps['redis.port']}"
  32.           p:timeout="#{redisProps['redis.timeout']}"
  33.           p:password="#{redisProps['redis.password']}"
  34.           p:database="#{redisProps['redis.database']}" 
  35.           p:poolConfig-ref="jedisPoolConfig" 
  36.           p:usePool="true"/>
  37.  
  38.  
  39.     <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"
  40.           p:connectionFactory-ref="redisConnectionFactory"
  41.           p:keySerializer-ref="stringRedisSerializer"
  42.           p:valueSerializer-ref="jacksonJsonRedisSerializer"
  43.           p:hashKeySerializer-ref="stringRedisSerializer"
  44.           p:hashValueSerializer-ref="jacksonJsonRedisSerializer"/>
  45.  
  46.  
  47.    <bean id="jedisPool" class="redis.clients.jedis.JedisPool">
  48.       <constructor-arg ref="jedisPoolConfig"/>
  49.       <constructor-arg value="#{redisProps['redis.ip']}"/>
  50.       <constructor-arg type="int" value="#{redisProps['redis.port']}"/>
  51.       <constructor-arg type="int" value="#{redisProps['redis.timeout']}"/>
  52.       <constructor-arg type="java.lang.String" value="#{redisProps['redis.password']}"/>
  53.       <constructor-arg type="int" value="#{redisProps['redis.database']}"/>
  54.    </bean>
  55.           
  56. </beans>

 

 

 

redis.properties的文件内容如下，maven管理的话，可以分别设置开发环境，测试环境，预发布环境，生产环境等

 

  1. redis.pool.maxActive=1024
  2. redis.pool.maxIdle=200
  3. redis.pool.maxWait=1000
  4. redis.pool.testOnBorrow=true
  5. redis.pool.testOnReturn=true
  6.  
  7. #database
  8. redis.ip=192.168.0.246
  9. redis.port=6378
  10. redis.password=
  11. redis.timeout=5000
  12. redis.database=1

 

 

 

工具类如下:

 

  1. package com.yjy.dg.app.report.dao;
  2.  
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.data.redis.core.ListOperations;
  7. import org.springframework.data.redis.core.RedisTemplate;
  8. import org.springframework.data.redis.core.SetOperations;
  9. import org.springframework.data.redis.core.ValueOperations;
  10.  
  11. import java.util.List;
  12. import java.util.Set;
  13. import java.util.concurrent.TimeUnit;
  14.  
  15. /**
  16.  * ParentDao  操作字符串redis缓存方法
  17.  *            list中的操作全是按照right方式
  18.  *
  19.  * @author littlehow
  20.  * @time 2016-08-12 09:02
  21.  */
  22. public class RedisParentDao {
  23.     /**
  24.      * 日志记录
  25.      */
  26.     private Logger logger = LoggerFactory.getLogger(this.getClass());
  27.     @Autowired
  28.     protected RedisTemplate<String, String> redisTemplate;
  29.     /**
  30.      * 前缀
  31.      */
  32.     public static final String KEY_PREFIX_VALUE = "dg:report:value:";
  33.     public static final String KEY_PREFIX_SET = "dg:report:set:";
  34.     public static final String KEY_PREFIX_LIST = "dg:report:list:";
  35.  
  36.     /**
  37.      * 缓存value操作
  38.      * @param k
  39.      * @param v
  40.      * @param time
  41.      * @return
  42.      */
  43.     protected boolean cacheValue(String k, String v, long time) {
  44.         String key = KEY_PREFIX_VALUE + k;
  45.         try {
  46.             ValueOperations<String, String> valueOps =  redisTemplate.opsForValue();
  47.             valueOps.set(key, v);
  48.             if (time > 0) redisTemplate.expire(key, time, TimeUnit.SECONDS);
  49.             return true;
  50.         } catch (Throwable t) {
  51.             logger.error("缓存[" + key + "]失败, value[" + v + "]", t);
  52.         }
  53.         return false;
  54.     }
  55.  
  56.     /**
  57.      * 缓存value操作
  58.      * @param k
  59.      * @param v
  60.      * @return
  61.      */
  62.     protected boolean cacheValue(String k, String v) {
  63.         return cacheValue(k, v, -1);
  64.     }
  65.  
  66.     /**
  67.      * 判断缓存是否存在
  68.      * @param k
  69.      * @return
  70.      */
  71.     protected boolean containsValueKey(String k) {
  72.         return containsKey(KEY_PREFIX_VALUE + k);
  73.     }
  74.  
  75.     /**
  76.      * 判断缓存是否存在
  77.      * @param k
  78.      * @return
  79.      */
  80.     protected boolean containsSetKey(String k) {
  81.         return containsKey(KEY_PREFIX_SET + k);
  82.     }
  83.  
  84.     /**
  85.      * 判断缓存是否存在
  86.      * @param k
  87.      * @return
  88.      */
  89.     protected boolean containsListKey(String k) {
  90.         return containsKey(KEY_PREFIX_LIST + k);
  91.     }
  92.  
  93.     protected boolean containsKey(String key) {
  94.         try {
  95.             return redisTemplate.hasKey(key);
  96.         } catch (Throwable t) {
  97.             logger.error("判断缓存存在失败key[" + key + ", error[" + t + "]");
  98.         }
  99.         return false;
  100.     }
  101.  
  102.     /**
  103.      * 获取缓存
  104.      * @param k
  105.      * @return
  106.      */
  107.     protected String getValue(String k) {
  108.         try {
  109.             ValueOperations<String, String> valueOps =  redisTemplate.opsForValue();
  110.             return valueOps.get(KEY_PREFIX_VALUE + k);
  111.         } catch (Throwable t) {
  112.             logger.error("获取缓存失败key[" + KEY_PREFIX_VALUE + k + ", error[" + t + "]");
  113.         }
  114.         return null;
  115.     }
  116.  
  117.     /**
  118.      * 移除缓存
  119.      * @param k
  120.      * @return
  121.      */
  122.     protected boolean removeValue(String k) {
  123.         return remove(KEY_PREFIX_VALUE + k);
  124.     }
  125.  
  126.     protected boolean removeSet(String k) {
  127.         return remove(KEY_PREFIX_SET + k);
  128.     }
  129.  
  130.     protected boolean removeList(String k) {
  131.         return remove(KEY_PREFIX_LIST + k);
  132.     }
  133.  
  134.     /**
  135.      * 移除缓存
  136.      * @param key
  137.      * @return
  138.      */
  139.     protected boolean remove(String key) {
  140.         try {
  141.             redisTemplate.delete(key);
  142.             return true;
  143.         } catch (Throwable t) {
  144.             logger.error("获取缓存失败key[" + key + ", error[" + t + "]");
  145.         }
  146.         return false;
  147.     }
  148.     /**
  149.      * 缓存set操作
  150.      * @param k
  151.      * @param v
  152.      * @param time
  153.      * @return
  154.      */
  155.     protected boolean cacheSet(String k, String v, long time) {
  156.         String key = KEY_PREFIX_SET + k;
  157.         try {
  158.             SetOperations<String, String> valueOps =  redisTemplate.opsForSet();
  159.             valueOps.add(key, v);
  160.             if (time > 0) redisTemplate.expire(key, time, TimeUnit.SECONDS);
  161.             return true;
  162.         } catch (Throwable t) {
  163.             logger.error("缓存[" + key + "]失败, value[" + v + "]", t);
  164.         }
  165.         return false;
  166.     }
  167.  
  168.     /**
  169.      * 缓存set
  170.      * @param k
  171.      * @param v
  172.      * @return
  173.      */
  174.     protected boolean cacheSet(String k, String v) {
  175.         return cacheSet(k, v, -1);
  176.     }
  177.  
  178.     /**
  179.      * 缓存set
  180.      * @param k
  181.      * @param v
  182.      * @param time
  183.      * @return
  184.      */
  185.     protected boolean cacheSet(String k, Set<String> v, long time) {
  186.         String key = KEY_PREFIX_SET + k;
  187.         try {
  188.             SetOperations<String, String> setOps =  redisTemplate.opsForSet();
  189.             setOps.add(key, v.toArray(new String[v.size()]));
  190.             if (time > 0) redisTemplate.expire(key, time, TimeUnit.SECONDS);
  191.             return true;
  192.         } catch (Throwable t) {
  193.             logger.error("缓存[" + key + "]失败, value[" + v + "]", t);
  194.         }
  195.         return false;
  196.     }
  197.  
  198.     /**
  199.      * 缓存set
  200.      * @param k
  201.      * @param v
  202.      * @return
  203.      */
  204.     protected boolean cacheSet(String k, Set<String> v) {
  205.         return cacheSet(k, v, -1);
  206.     }
  207.  
  208.     /**
  209.      * 获取缓存set数据
  210.      * @param k
  211.      * @return
  212.      */
  213.     protected Set<String> getSet(String k) {
  214.         try {
  215.             SetOperations<String, String> setOps = redisTemplate.opsForSet();
  216.             return setOps.members(KEY_PREFIX_SET + k);
  217.         } catch (Throwable t) {
  218.             logger.error("获取set缓存失败key[" + KEY_PREFIX_SET + k + ", error[" + t + "]");
  219.         }
  220.         return null;
  221.     }
  222.  
  223.     /**
  224.      * list缓存
  225.      * @param k
  226.      * @param v
  227.      * @param time
  228.      * @return
  229.      */
  230.     protected boolean cacheList(String k, String v, long time) {
  231.         String key = KEY_PREFIX_LIST + k;
  232.         try {
  233.             ListOperations<String, String> listOps =  redisTemplate.opsForList();
  234.             listOps.rightPush(key, v);
  235.             if (time > 0) redisTemplate.expire(key, time, TimeUnit.SECONDS);
  236.             return true;
  237.         } catch (Throwable t) {
  238.             logger.error("缓存[" + key + "]失败, value[" + v + "]", t);
  239.         }
  240.         return false;
  241.     }
  242.  
  243.     /**
  244.      * 缓存list
  245.      * @param k
  246.      * @param v
  247.      * @return
  248.      */
  249.     protected boolean cacheList(String k, String v) {
  250.         return cacheList(k, v, -1);
  251.     }
  252.  
  253.     /**
  254.      * 缓存list
  255.      * @param k
  256.      * @param v
  257.      * @param time
  258.      * @return
  259.      */
  260.     protected boolean cacheList(String k, List<String> v, long time) {
  261.         String key = KEY_PREFIX_LIST + k;
  262.         try {
  263.             ListOperations<String, String> listOps =  redisTemplate.opsForList();
  264.             long l = listOps.rightPushAll(key, v);
  265.             if (time > 0) redisTemplate.expire(key, time, TimeUnit.SECONDS);
  266.             return true;
  267.         } catch (Throwable t) {
  268.             logger.error("缓存[" + key + "]失败, value[" + v + "]", t);
  269.         }
  270.         return false;
  271.     }
  272.  
  273.     /**
  274.      * 缓存list
  275.      * @param k
  276.      * @param v
  277.      * @return
  278.      */
  279.     protected boolean cacheList(String k, List<String> v) {
  280.        return cacheList(k, v, -1);
  281.     }
  282.  
  283.     /**
  284.      * 获取list缓存
  285.      * @param k
  286.      * @param start
  287.      * @param end
  288.      * @return
  289.      */
  290.     protected List<String> getList(String k, long start, long end) {
  291.         try {
  292.             ListOperations<String, String> listOps =  redisTemplate.opsForList();
  293.             return listOps.range(KEY_PREFIX_LIST + k, start, end);
  294.         } catch (Throwable t) {
  295.             logger.error("获取list缓存失败key[" + KEY_PREFIX_LIST + k + ", error[" + t + "]");
  296.         }
  297.         return null;
  298.     }
  299.  
  300.     /**
  301.      * 获取总条数, 可用于分页
  302.      * @param k
  303.      * @return
  304.      */
  305.     protected long getListSize(String k) {
  306.         try {
  307.             ListOperations<String, String> listOps =  redisTemplate.opsForList();
  308.             return listOps.size(KEY_PREFIX_LIST + k);
  309.         } catch (Throwable t) {
  310.             logger.error("获取list长度失败key[" + KEY_PREFIX_LIST + k + "], error[" + t + "]");
  311.         }
  312.         return 0;
  313.     }
  314.  
  315.     /**
  316.      * 获取总条数, 可用于分页
  317.      * @param listOps
  318.      * @param k
  319.      * @return
  320.      */
  321.     protected long getListSize(ListOperations<String, String> listOps, String k) {
  322.         try {
  323.             return listOps.size(KEY_PREFIX_LIST + k);
  324.         } catch (Throwable t) {
  325.             logger.error("获取list长度失败key[" + KEY_PREFIX_LIST + k + "], error[" + t + "]");
  326.         }
  327.         return 0;
  328.     }
  329.  
  330.     /**
  331.      * 移除list缓存
  332.      * @param k
  333.      * @return
  334.      */
  335.     protected boolean removeOneOfList(String k) {
  336.         String key = KEY_PREFIX_LIST + k;
  337.         try {
  338.             ListOperations<String, String> listOps =  redisTemplate.opsForList();
  339.             listOps.rightPop(KEY_PREFIX_LIST + k);
  340.             return true;
  341.         } catch (Throwable t) {
  342.             logger.error("移除list缓存失败key[" + KEY_PREFIX_LIST + k + ", error[" + t + "]");
  343.         }
  344.         return false;
  345.     }
  346. }

 

 

 

以上就是对redis的操作工具实现了，学习笔记over

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/220850
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号