1.在pom文件中加入redis依赖

  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-data-redis</artifactId>
  4. </dependency>
  5. <dependency>
  6.     <groupId>redis.clients</groupId>
  7.     <artifactId>jedis</artifactId>
  8.     <version>3.0.1</version>
  9. </dependency>

2.在application.yml文件中配置redis属性

  1. spring:
  2.   redis:
  3.     database: 0 # Redis数据库索引（默认为0）
  4.     host: 127.0.0.1 # Redis服务器地址
  5.     port: 6379  # Redis服务器连接端口
  6.     password: huang # Redis服务器连接密码（默认为空）
  7.     jedis:
  8.       pool:
  9.         max-active: 500 # 连接池最大连接数（使用负值表示没有限制）
  10.         max-wait: 10000 # 连接池最大阻塞等待时间（使用负值表示没有限制）
  11.         max-idle: 500 # 连接池中的最大空闲连接
  12.         min-idle: 8 # 连接池中的最小空闲连接
  13.      timeout: 1000 # 连接超时时间（毫秒）

3.使用

1.简单实用jedis

  1. public void test(){
  2.         Jedis jedis= new Jedis("127.0.0.1");
  3.         jedis.auth("huang");
  4.         System.out.println("服务正在运行: "+jedis.ping());
  5.         Set<String> keys = jedis.keys("*");
  6.         for (String key : keys) {
  7.             System.out.println(key+"-"+jedis.get(key));
  8.         }
  9.         // 字符串实例
  10.         jedis.set("myKey","myKey");
  11.         System.out.println("redis 存储的字符串为:"+jedis.get("myKey"));
  12.         // List实例
  13.         jedis.lpush("myList", "list1");
  14.         jedis.lpush("myList", "list2");
  15.         jedis.lpush("myList", "list3");
  16.         List<String> list = jedis.lrange("myList", 0 ,2);
  17.         for (String s : list) {
  18.             System.out.println("列表项为: " + s);
  19.         }
  20.     }

2.配置Redis，创建redisUitls工具类

2.1配置Redis

  1. package com.example.demo.redis;
  3. import com.fasterxml.jackson.annotation.JsonAutoDetect;
  4. import com.fasterxml.jackson.annotation.PropertyAccessor;
  5. import com.fasterxml.jackson.databind.ObjectMapper;
  6. import org.springframework.beans.factory.annotation.Value;
  7. import org.springframework.cache.annotation.CachingConfigurerSupport;
  8. import org.springframework.cache.annotation.EnableCaching;
  9. import org.springframework.context.annotation.Bean;
  10. import org.springframework.context.annotation.Configuration;
  11. import org.springframework.data.redis.connection.RedisConnectionFactory;
  12. import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
  13. import org.springframework.data.redis.core.*;
  14. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  15. import org.springframework.data.redis.serializer.StringRedisSerializer;
  16. import redis.clients.jedis.JedisPoolConfig;
  19. @Configuration
  20. @EnableCaching
  21. public class RedisConfig extends CachingConfigurerSupport {
  23.     @Value("${spring.redis.host}")
  24.     private String host;
  25.     @Value("${spring.redis.port}")
  26.     private Integer port;
  27.     @Value("${spring.redis.password}")
  28.     private String password;
  29.     @Value("${spring.redis.timeout}")
  30.     private Integer timout;
  31.     @Value("${spring.redis.jedis.pool.max-idle}")
  32.     private Integer maxIdl;//链接池最大空闲数
  33.     @Value("${spring.redis.jedis.pool.min-idle}")
  34.     private Integer minIdl;//链接池最小空闲数
  35.     @Value("${spring.redis.jedis.pool.max-active}")
  36.     private Integer maxActive;//链接池最大链接数
  37.     @Value("${spring.redis.jedis.pool.max-wait}")
  38.     private Integer maxWait;//连接池最大阻塞时间
  39.     @Value("${spring.redis.database}")
  40.     private Integer database;//redis数据库索引数
  42.     @Bean
  43.     public RedisConnectionFactory getfactory(){
  44.         JedisPoolConfig config=new JedisPoolConfig();
  45.         config.setMaxIdle(maxIdl);
  46.         config.setMinIdle(minIdl);
  47.         config.setMaxWaitMillis(maxWait);
  48.         config.setMaxTotal(maxActive);
  50.         //获取链接检查有效性
  51.         config.setTestOnBorrow(false);
  52.         //部署时为true
  53. //        config.setTestOnCreate(false);
  54.         //返回验证信息
  55.         config.setTestOnReturn(false);
  56.         //链接最近是否阻塞
  57.         config.setBlockWhenExhausted(true);
  58.         JedisConnectionFactory jedisConnectionFactory=new JedisConnectionFactory(config);
  59.         jedisConnectionFactory.setHostName(host);
  60.         jedisConnectionFactory.setPort(port);
  61.         jedisConnectionFactory.setDatabase(database);
  62.         if(!password.isEmpty()){
  63.             jedisConnectionFactory.setPassword(password);
  64.         }
  65.         jedisConnectionFactory.setTimeout(timout);
  66.         return jedisConnectionFactory;
  67.     }
  70.     @Bean
  71.     public RedisTemplate<String,Object> redisTemplate(){
  73.         RedisTemplate<String,Object> redisTemplate=new RedisTemplate<>();
  74.         //配置链接工厂
  75.         redisTemplate.setConnectionFactory(getfactory());
  76.         //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
  77.         Jackson2JsonRedisSerializer jsonRedisSerializer=new Jackson2JsonRedisSerializer(Object.class);
  79.         ObjectMapper om=new ObjectMapper();
  80.         // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
  81.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  82.         // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
  83.         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  84.         jsonRedisSerializer.setObjectMapper(om);
  85.         //值采用json系列化
  86.         redisTemplate.setValueSerializer(jsonRedisSerializer);
  87.         //使用StringRedisSerializer来序列化和反序列化redis的key值
  88.         redisTemplate.setKeySerializer(new StringRedisSerializer());
  90.         //设置hash key和value的序列化模式
  91.         redisTemplate.setHashKeySerializer(new StringRedisSerializer());
  92.         redisTemplate.setHashValueSerializer(jsonRedisSerializer);
  93.         redisTemplate.afterPropertiesSet();
  94.         return redisTemplate;
  95.     }
  97.     /**
  98.      * 对hash类型的数据操作
  99.      * @param redisTemplate
  100.      * @return
  101.      */
  102.     @Bean
  103.     public HashOperations<String,String,Object> hashOperations(RedisTemplate<String,Object> redisTemplate){
  104.         return redisTemplate.opsForHash();
  105.     }
  108.     /**
  109.      * 对redis字符串类型的操作
  110.      * @param redisTemplate
  111.      * @return
  112.      */
  113.     @Bean
  114.     public ValueOperations<String,Object> valueOperations(RedisTemplate<String,Object> redisTemplate){
  115.         return redisTemplate.opsForValue();
  116.     }
  118.     /**
  119.      * 对链表类型的操作
  120.      * @param redisTemplate
  121.      * @return
  122.      */
  123.     @Bean
  124.     public ListOperations<String,Object> listOperations(RedisTemplate<String,Object> redisTemplate){
  125.         return redisTemplate.opsForList();
  126.     }
  128.     /**
  129.      * 对redis无序集合类型的数据操作
  130.      * @param redisTemplate
  131.      * @return
  132.      */
  133.     @Bean
  134.     public SetOperations<String,Object> setOperations(RedisTemplate<String,Object> redisTemplate){
  135.         return redisTemplate.opsForSet();
  136.     }
  138.     /**
  139.      * 对redis有序集合类型的数据操作
  140.      * @param redisTemplate
  141.      * @return
  142.      */
  143.     public ZSetOperations<String,Object> zSetOperations(RedisTemplate<String,Object> redisTemplate){
  144.         return redisTemplate.opsForZSet();
  145.     }
  147. }

2.2创建redisUitls工具类

  1. package com.example.demo.redis;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.data.redis.core.BoundListOperations;
  5. import org.springframework.data.redis.core.RedisConnectionUtils;
  6. import org.springframework.data.redis.core.RedisTemplate;
  7. import org.springframework.stereotype.Component;
  9. import java.util.List;
  10. import java.util.Map;
  11. import java.util.Set;
  12. import java.util.concurrent.TimeUnit;
  14. @Component
  15. public class RedisUtil {
  17.     @Autowired
  18.     private RedisTemplate<String,Object> redisTemplate;
  20.     public RedisUtil(RedisTemplate<String,Object> redisTemplate) {
  21.         this.redisTemplate=redisTemplate;
  22.     }
  24.     //释放连接池资源
  25.     public void backRedis(){
  26.         RedisConnectionUtils.unbindConnection(redisTemplate.getConnectionFactory());
  27.     }
  29.     /**
  30.      * 指定缓存失效时间
  31.      * @param key 键
  32.      * @param time 时间(秒)
  33.      * @return
  34.      */
  35.     public boolean expire(String key,long time){
  36.         try {
  37.             if(time>0){
  38.                 redisTemplate.expire(key,time, TimeUnit.SECONDS);
  39.             }
  40.             return true;
  41.         } catch (Exception e) {
  42.             e.printStackTrace();
  43.             return false;
  44.         }finally{
  45.             backRedis();//释放连接资源
  47.         }
  48.     }
  50.     /**
  51.      * 根据key 获取过期时间
  52.      * @param key 键 不能为null
  53.      * @return 时间(秒) 返回0代表为永久有效
  54.      */
  55.     public long getExpire(String key){
  56.         try {
  57.             return redisTemplate.getExpire(key,TimeUnit.SECONDS);
  58.         } catch (Exception e) {
  59.             e.printStackTrace();
  60.             return 0;
  61.         }finally{
  62.             backRedis();//释放连接资源
  63.         }
  64.     }
  66.     /**
  67.      * 判断key是否存在
  68.      * @param key 键
  69.      * @return true 存在 false不存在
  70.      */
  71.     public boolean hasKey(String key){
  72.         try {
  73.             return redisTemplate.hasKey(key);
  74.         } catch (Exception e) {
  75.             e.printStackTrace();
  76.             return false;
  77.         }finally{
  78.             backRedis();//释放连接资源
  79.         }
  80.     }
  82.     /**
  83.      * 删除一个缓存
  84.      * @param key 可以传一个值
  85.      */
  86.     public void delOne(String key){
  88.         try {
  89.             redisTemplate.delete(key);
  90.         } catch (Exception e) {
  91.             e.printStackTrace();
  92.         }finally{
  93.             backRedis();//释放连接资源
  94.         }
  95.     }
  97.     /**
  98.      * 删除多个缓存
  99.      * @param keys
  100.      */
  101.     public void delKeys(List<String> keys){
  103.         try {
  104.             redisTemplate.delete(keys);
  105.         } catch (Exception e) {
  106.             e.printStackTrace();
  107.         }finally{
  108.             backRedis();//释放连接资源
  109.         }
  110.     }
  112.     //***************** String **********************
  114.     /**
  115.      * 普通缓存获取
  116.      * @param key 键
  117.      * @return 值
  118.      */
  119.     public Object get(String key){
  121.         try {
  122.             return key==null?null:redisTemplate.opsForValue().get(key);
  123.         } catch (Exception e) {
  124.             e.printStackTrace();
  125.             return null;
  126.         }finally{
  127.             backRedis();//释放连接资源
  128.         }
  129.     }
  131.     /**
  132.      * 普通缓存放入
  133.      * @param key 键
  134.      * @param value 值
  135.      * @return true成功 false失败
  136.      */
  137.     public boolean set(String key,Object value) {
  138.         try {
  139.             redisTemplate.opsForValue().set(key, value);
  140.             return true;
  141.         } catch (Exception e) {
  142.             e.printStackTrace();
  143.             return false;
  144.         }finally{
  145.             backRedis();//释放连接资源
  146.         }
  147.     }
  149.     /**
  150.      * 普通缓存放入并设置时间
  151.      * @param key 键
  152.      * @param value 值
  153.      * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
  154.      * @return true成功 false 失败
  155.      */
  156.     public boolean set(String key,Object value,long time){
  157.         try {
  158.             if(time>0){
  159.                 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
  160.             }else{
  161.                 set(key, value);
  162.             }
  163.             return true;
  164.         } catch (Exception e) {
  165.             e.printStackTrace();
  166.             return false;
  167.         }finally{
  168.             backRedis();
  169.         }
  170.     }
  173.     /**
  174.      * 递增
  175.      * @param key 键
  176.      * @param delta 要增加几(大于0)
  177.      * @return
  178.      */
  179.     public long incr(String key, long delta){
  180.         if(delta<0){
  181.             throw new RuntimeException("递增因子必须大于0");
  182.         }
  183.         try {
  184.             return redisTemplate.opsForValue().increment(key, delta);
  185.         } catch (Exception e) {
  186.             e.printStackTrace();
  187.             return 0;
  188.         }finally{
  189.             backRedis();//释放连接资源
  190.         }
  191.     }
  193.     /**
  194.      * 递减
  195.      * @param key 键
  196.      * @param delta 要减少几(小于0)
  197.      * @return
  198.      */
  199.     public long decr(String key, long delta){
  200.         if(delta<0){
  201.             throw new RuntimeException("递减因子必须大于0");
  202.         }
  203.         try {
  204.             return redisTemplate.opsForValue().increment(key, -delta);
  205.         } catch (Exception e) {
  206.             e.printStackTrace();
  207.             return 0;
  208.         }finally{
  209.             backRedis();//释放连接资源
  210.         }
  211.     }
  213.     //============================== Hash ===============================
  215.     /**
  216.      * HashGet
  217.      * @param key 键 不能为null
  218.      * @param item 项 不能为null
  219.      * @return 值
  220.      */
  221.     public Object hGet(String key,String item){
  222.         try {
  223.             return redisTemplate.opsForHash().get(key, item);
  224.         } catch (Exception e) {
  225.             e.printStackTrace();
  226.             return null;
  227.         }finally{
  228.             backRedis();//释放连接资源
  229.         }
  230.     }
  232.     /**
  233.      * 获取hashKey对应的所有键值
  234.      * @param key 键
  235.      * @return 对应的多个键值
  236.      */
  237.     public Map<Object,Object> hmGet(String key){
  238.         try {
  239.             return redisTemplate.opsForHash().entries(key);
  240.         } catch (Exception e) {
  241.             e.printStackTrace();
  242.             return null;
  243.         }finally{
  244.             backRedis();//释放连接资源
  245.         }
  246.     }
  248.     /**
  249.      * HashSet
  250.      * @param key 键
  251.      * @param map 对应多个键值
  252.      * @return true 成功 false 失败
  253.      */
  254.     public boolean hMapSet(String key, Map<String,Object> map){
  255.         try {
  256.             redisTemplate.opsForHash().putAll(key, map);
  257.             return true;
  258.         } catch (Exception e) {
  259.             e.printStackTrace();
  260.             return false;
  261.         }finally{
  262.             backRedis();
  263.         }
  264.     }
  266.     /**
  267.      * HashSet 并设置时间
  268.      * @param key 键
  269.      * @param map 对应多个键值
  270.      * @param time 时间(秒)
  271.      * @return true成功 false失败
  272.      */
  273.     public boolean hmSetTime(String key, Map<String,Object> map, long time){
  274.         try {
  275.             redisTemplate.opsForHash().putAll(key, map);
  276.             if(time>0){
  277.                 expire(key, time);
  278.             }
  279.             return true;
  280.         } catch (Exception e) {
  281.             e.printStackTrace();
  282.             return false;
  283.         }finally{
  284.             backRedis();
  285.         }
  286.     }
  288.     /**
  289.      * 向一张hash表中放入数据,如果不存在将创建
  290.      * @param key 键
  291.      * @param item 项
  292.      * @param value 值
  293.      * @return true 成功 false失败
  294.      */
  295.     public boolean hSave(String key,String item,Object value) {
  296.         try {
  297.             redisTemplate.opsForHash().put(key, item, value);
  298.             return true;
  299.         } catch (Exception e) {
  300.             e.printStackTrace();
  301.             return false;
  302.         }finally{
  303.             backRedis();
  304.         }
  305.     }
  307.     /**
  308.      * 向一张hash表中放入数据,如果不存在将创建
  309.      * @param key 键
  310.      * @param item 项
  311.      * @param value 值
  312.      * @param time 时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
  313.      * @return true 成功 false失败
  314.      */
  315.     public boolean hSaveTime(String key,String item,Object value,long time) {
  316.         try {
  317.             redisTemplate.opsForHash().put(key, item, value);
  318.             if(time>0){
  319.                 expire(key, time);
  320.             }
  321.             return true;
  322.         } catch (Exception e) {
  323.             e.printStackTrace();
  324.             return false;
  325.         }finally{
  326.             backRedis();
  327.         }
  328.     }
  330.     /**
  331.      * 删除hash表中的值
  332.      * @param key 键 不能为null
  333.      * @param item 项 可以使多个 不能为null
  334.      */
  335.     public void hDel(String key, Object item){
  336.         try {
  337.             redisTemplate.opsForHash().delete(key,item);
  338.         } catch (Exception e) {
  339.             e.printStackTrace();
  340.         }finally{
  341.             backRedis();
  342.         }
  343.     }
  345.     /**
  346.      * 判断hash表中是否有该项的值
  347.      * @param key 键 不能为null
  348.      * @param item 项 不能为null
  349.      * @return true 存在 false不存在
  350.      */
  351.     public boolean hHasKey(String key, String item){
  352.         try {
  353.             return redisTemplate.opsForHash().hasKey(key, item);
  354.         } catch (Exception e) {
  355.             e.printStackTrace();
  356.             return false;
  357.         }finally{
  358.             backRedis();
  359.         }
  360.     }
  362.     /**
  363.      * hash递增 如果不存在,就会创建一个 并把新增后的值返回
  364.      * @param key 键
  365.      * @param item 项
  366.      * @param by 要增加几(大于0)
  367.      * @return
  368.      */
  369.     public double hIncr(String key, String item,double by){
  370.         try {
  371.             return redisTemplate.opsForHash().increment(key, item, by);
  372.         } catch (Exception e) {
  373.             e.printStackTrace();
  374.             return 0;
  375.         }finally{
  376.             backRedis();
  377.         }
  378.     }
  380.     /**
  381.      * hash递减
  382.      * @param key 键
  383.      * @param item 项
  384.      * @param by 要减少记(小于0)
  385.      * @return
  386.      */
  387.     public double hDecr(String key, String item,double by){
  388.         try {
  389.             return redisTemplate.opsForHash().increment(key, item,-by);
  390.         } catch (Exception e) {
  391.             e.printStackTrace();
  392.             return 0;
  393.         }finally{
  394.             backRedis();
  395.         }
  396.     }
  398.     //=========================== set ============================
  400.     /**
  401.      * 根据key获取Set中的所有值
  402.      * @param key 键
  403.      * @return
  404.      */
  405.     public Set<Object> sGet(String key){
  406.         try {
  407.             return redisTemplate.opsForSet().members(key);
  408.         } catch (Exception e) {
  409.             e.printStackTrace();
  410.             return null;
  411.         }finally{
  412.             backRedis();
  413.         }
  414.     }
  416.     /**
  417.      * 根据value从一个set中查询,是否存在
  418.      * @param key 键
  419.      * @param value 值
  420.      * @return true 存在 false不存在
  421.      */
  422.     public boolean sHasKey(String key,Object value){
  423.         try {
  424.             return redisTemplate.opsForSet().isMember(key, value);
  425.         } catch (Exception e) {
  426.             e.printStackTrace();
  427.             return false;
  428.         }finally{
  429.             backRedis();
  430.         }
  431.     }
  433.     /**
  434.      * 将数据放入set缓存
  435.      * @param key 键
  436.      * @param values 值 可以是多个
  437.      * @return 成功个数
  438.      */
  439.     public long sSet(String key, Object values) {
  440.         try {
  441.             return redisTemplate.opsForSet().add(key, values);
  442.         } catch (Exception e) {
  443.             e.printStackTrace();
  444.             return 0;
  445.         }finally{
  446.             backRedis();
  447.         }
  448.     }
  450.     /**
  451.      * 将set数据放入缓存
  452.      * @param key 键
  453.      * @param time 时间(秒)
  454.      * @param values 值 可以是多个
  455.      * @return 成功个数
  456.      */
  457.     public long sSetAndTime(String key,long time,Object values) {
  458.         try {
  459.             Long count = redisTemplate.opsForSet().add(key, values);
  460.             if(time>0) {
  461.                 expire(key, time);
  462.             }
  463.             return count;
  464.         } catch (Exception e) {
  465.             e.printStackTrace();
  466.             return 0;
  467.         }finally{
  468.             backRedis();
  469.         }
  470.     }
  472.     /**
  473.      * 获取set缓存的长度
  474.      * @param key 键
  475.      * @return
  476.      */
  477.     public long sGetSetSize(String key){
  478.         try {
  479.             return redisTemplate.opsForSet().size(key);
  480.         } catch (Exception e) {
  481.             e.printStackTrace();
  482.             return 0;
  483.         }finally{
  484.             backRedis();
  485.         }
  486.     }
  488.     /**
  489.      * 移除值为value的
  490.      * @param key 键
  491.      * @param values 值 可以是多个
  492.      * @return 移除的个数
  493.      */
  494.     public long setRemove(String key, Object values) {
  495.         try {
  496.             Long count = redisTemplate.opsForSet().remove(key, values);
  497.             return count;
  498.         } catch (Exception e) {
  499.             e.printStackTrace();
  500.             return 0;
  501.         }finally{
  502.             backRedis();
  503.         }
  504.     }
  505.     //===============================list=================================
  507.     /**
  508.      * 获取list缓存的内容
  509.      * @param key 键
  510.      * @param start 开始
  511.      * @param end 结束  0 到 -1代表所有值
  512.      * @return
  513.      */
  514.     public List<Object> lGet(String key, long start, long end){
  515.         try {
  516.             return redisTemplate.opsForList().range(key, start, end);
  517.         } catch (Exception e) {
  518.             e.printStackTrace();
  519.             return null;
  520.         }finally{
  521.             backRedis();
  522.         }
  523.     }
  525.     /**
  526.      * 获取list缓存的长度
  527.      * @param key 键
  528.      * @return
  529.      */
  530.     public long lGetListSize(String key){
  531.         try {
  532.             return redisTemplate.opsForList().size(key);
  533.         } catch (Exception e) {
  534.             e.printStackTrace();
  535.             return 0;
  536.         }finally{
  537.             backRedis();
  538.         }
  539.     }
  541.     /**
  542.      * 通过索引 获取list中的值
  543.      * @param key 键
  544.      * @param index 索引  index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
  545.      * @return
  546.      */
  547.     public Object lGetIndex(String key,long index){
  548.         try {
  549.             return redisTemplate.opsForList().index(key, index);
  550.         } catch (Exception e) {
  551.             e.printStackTrace();
  552.             return null;
  553.         }finally{
  554.             backRedis();
  555.         }
  556.     }
  558.     /**
  559.      * 将list放入缓存
  560.      * @param key 键
  561.      * @param value 值
  562.      * @return
  563.      */
  564.     public boolean lpush(String key, Object value) {
  565.         try {
  566.             redisTemplate.opsForList().rightPush(key, value);
  567.             return true;
  568.         } catch (Exception e) {
  569.             e.printStackTrace();
  570.             return false;
  571.         }finally{
  572.             backRedis();
  573.         }
  574.     }
  576.     /**
  577.      * 将list放入缓存
  578.      * @param key 键
  579.      * @param value 值
  580.      * @param time 时间(秒)
  581.      * @return
  582.      */
  583.     public boolean lpushTime(String key, Object value, long time) {
  584.         try {
  585.             redisTemplate.opsForList().rightPush(key, value);
  586.             if (time > 0) {
  587.                 expire(key, time);
  588.             }
  589.             return true;
  590.         } catch (Exception e) {
  591.             e.printStackTrace();
  592.             return false;
  593.         }finally{
  594.             backRedis();
  595.         }
  596.     }
  598.     /**
  599.      * 将list放入缓存
  600.      * @param key 键
  601.      * @param value 值
  602.      * @return
  603.      */
  604.     public boolean lpushAll(String key, List value) {
  605.         try {
  606.             redisTemplate.opsForList().rightPushAll(key, value);
  607.             return true;
  608.         } catch (Exception e) {
  609.             e.printStackTrace();
  610.             return false;
  611.         }finally{
  612.             backRedis();
  613.         }
  614.     }
  616.     /**
  617.      * 将list放入缓存
  618.      * @param key 键
  619.      * @param value 值
  620.      * @param time 时间(秒)
  621.      * @return
  622.      */
  623.     public boolean lpushAllTime(String key, List<Object> value, long time) {
  624.         try {
  625.             redisTemplate.opsForList().rightPushAll(key, value);
  626.             if (time > 0) {
  627.                 expire(key, time);
  628.             }
  629.             return true;
  630.         } catch (Exception e) {
  631.             e.printStackTrace();
  632.             return false;
  633.         }finally{
  634.             backRedis();
  635.         }
  636.     }
  638.     /**
  639.      * 根据索引修改list中的某条数据
  640.      * @param key 键
  641.      * @param index 索引
  642.      * @param value 值
  643.      * @return
  644.      */
  645.     public boolean lUpdateIndex(String key, long index,Object value) {
  646.         try {
  647.             redisTemplate.opsForList().set(key, index, value);
  648.             return true;
  649.         } catch (Exception e) {
  650.             e.printStackTrace();
  651.             return false;
  652.         }finally{
  653.             backRedis();
  654.         }
  655.     }
  657.     /**
  658.      * 移除N个值为value
  659.      * @param key 键
  660.      * @param count 移除多少个
  661.      * @param value 值
  662.      * @return 移除的个数
  663.      */
  664.     public long lRemove(String key,long count,Object value) {
  665.         try {
  666.             Long remove = redisTemplate.opsForList().remove(key, count, value);
  667.             return remove;
  668.         } catch (Exception e) {
  669.             e.printStackTrace();
  670.             return 0;
  671.         }finally{
  672.             backRedis();
  673.         }
  674.     }
  676.     /**
  677.      * 模糊查询获取key值
  678.      * @param pattern
  679.      * @return
  680.      */
  681.     public Set keys(String pattern){
  682.         try {
  683.             return redisTemplate.keys(pattern);
  684.         } catch (Exception e) {
  685.             e.printStackTrace();
  686.             return null;
  687.         }finally{
  688.             backRedis();
  689.         }
  690.     }
  692.     /**
  693.      * 使用Redis的消息队列
  694.      * @param channel
  695.      * @param message 消息内容
  696.      */
  697.     public void convertAndSend(String channel, Object message){
  698.         try {
  699.             redisTemplate.convertAndSend(channel,message);
  700.         } catch (Exception e) {
  701.             e.printStackTrace();
  702.         }finally{
  703.             backRedis();
  704.         }
  705.     }
  707.     //=========BoundListOperations 用法 start============
  709.     /**
  710.      *将数据添加到Redis的list中（从右边添加）
  711.      * @param listKey
  712.      * @param values 待添加的数据
  713.      */
  714.     public void addToListRight(String listKey,Object values) {
  715.         //绑定操作
  716.         BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey);
  717.         //插入数据
  718.         boundValueOperations.rightPushAll(values);
  719.         //设置过期时间
  721.     }
  722.     /**
  723.      * 根据起始结束序号遍历Redis中的list
  724.      * @param listKey
  725.      * @param start  起始序号
  726.      * @param end  结束序号
  727.      * @return
  728.      */
  729.     public List<Object> rangeList(String listKey, long start, long end) {
  730.         //绑定操作
  731.         BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey);
  732.         //查询数据
  733.         return boundValueOperations.range(start, end);
  734.     }
  735.     /**
  736.      * 弹出右边的值 --- 并且移除这个值
  737.      * @param listKey
  738.      */
  739.     public Object rifhtPop(String listKey){
  740.         //绑定操作
  741.         BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey);
  742.         return boundValueOperations.rightPop();
  743.     }
  745.     //=========BoundListOperations 用法 End============
  746. }