SpringBoot集成Redis——RedisTemplate方式

深碍√TFBOYSˉ_ 2022-03-16 05:28 1173阅读 0赞

本篇基于Springboot2.0 + Redis实现数据缓存以及分库存储，首先我们要知道，Springboot整合Redis有两种方式，分别是Jedis和RedisTemplate，这两者有何区别？

Jedis是Redis官方推荐的面向Java的操作Redis的客户端，而RedisTemplate是SpringDataRedis中对JedisApi的高度封装。其实在Springboot的官网上我们也能看到，官方现在推荐的是SpringDataRedis形式，相对于Jedis来说可以方便地更换Redis的Java客户端，其比Jedis多了自动管理连接池的特性，方便与其他Spring框架进行搭配使用如：SpringCache。

一、Redis基本配置及工具类

首先我们看下整个项目的目录结构，共分为三部分，pom包在文末给出

70

1.创建redis.properties配置文件

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

这些配置并不一定都需要,按照情况添加,全都添加也无大碍,其中我们必须要指定Redis的地址,端口及密码

2.添加配置类RedisConfig.java

  1. package com.springboot.demo.base.config;
  3. import com.springboot.demo.base.utils.FastJson2JsonRedisSerializer;
  4. import com.springboot.demo.base.utils.RedisUtil;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.springframework.beans.factory.annotation.Value;
  7. import org.springframework.context.annotation.Bean;
  8. import org.springframework.context.annotation.Configuration;
  9. import org.springframework.context.annotation.PropertySource;
  10. import org.springframework.data.redis.connection.RedisConnectionFactory;
  11. import org.springframework.data.redis.connection.RedisPassword;
  12. import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
  13. import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
  14. import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
  15. import com.springboot.demo.base.utils.RedisTemplate;
  16. import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
  17. import org.springframework.data.redis.serializer.RedisSerializer;
  18. import org.springframework.data.redis.serializer.StringRedisSerializer;
  20. import java.time.Duration;
  22. /**
  23.  * @ClassName: RedisConfig
  24.  * @Auther: zhangyingqi
  25.  * @Date: 2018/8/28 11:07
  26.  * @Description:
  27.  */
  28. @Configuration
  29. @PropertySource("classpath:redis.properties")
  30. @Slf4j
  31. public class RedisConfig {
  33.     @Value("${redis.hostName}")
  34.     private String hostName;
  36.     @Value("${redis.password}")
  37.     private String password;
  39.     @Value("${redis.port}")
  40.     private Integer port;
  42.     @Value("${redis.maxIdle}")
  43.     private Integer maxIdle;
  45.     @Value("${redis.timeout}")
  46.     private Integer timeout;
  48.     @Value("${redis.maxTotal}")
  49.     private Integer maxTotal;
  51.     @Value("${redis.maxWaitMillis}")
  52.     private Integer maxWaitMillis;
  54.     @Value("${redis.minEvictableIdleTimeMillis}")
  55.     private Integer minEvictableIdleTimeMillis;
  57.     @Value("${redis.numTestsPerEvictionRun}")
  58.     private Integer numTestsPerEvictionRun;
  60.     @Value("${redis.timeBetweenEvictionRunsMillis}")
  61.     private long timeBetweenEvictionRunsMillis;
  63.     @Value("${redis.testOnBorrow}")
  64.     private boolean testOnBorrow;
  66.     @Value("${redis.testWhileIdle}")
  67.     private boolean testWhileIdle;
  69.     /**
  70.      * @auther: zhangyingqi
  71.      * @date: 17:52 2018/8/28
  72.      * @param: []
  73.      * @return: org.springframework.data.redis.connection.jedis.JedisConnectionFactory
  74.      * @Description: Jedis配置
  75.      */
  76.     @Bean
  77.     public JedisConnectionFactory JedisConnectionFactory(){
  78.         RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration ();
  79.         redisStandaloneConfiguration.setHostName(hostName);
  80.         redisStandaloneConfiguration.setPort(port);
  81.         //由于我们使用了动态配置库,所以此处省略
  82.         //redisStandaloneConfiguration.setDatabase(database);
  83.         redisStandaloneConfiguration.setPassword(RedisPassword.of(password));
  84.         JedisClientConfiguration.JedisClientConfigurationBuilder jedisClientConfiguration = JedisClientConfiguration.builder();
  85.         jedisClientConfiguration.connectTimeout(Duration.ofMillis(timeout));
  86.         JedisConnectionFactory factory = new JedisConnectionFactory(redisStandaloneConfiguration,
  87.                 jedisClientConfiguration.build());
  88.         return factory;
  89.     }
  91.     /**
  92.      * @auther: zhangyingqi
  93.      * @date: 17:52 2018/8/28
  94.      * @param: [redisConnectionFactory]
  95.      * @return: com.springboot.demo.base.utils.RedisTemplate
  96.      * @Description: 实例化 RedisTemplate 对象
  97.      */
  98.     @Bean
  99.     public RedisTemplate functionDomainRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
  100.         log.info("RedisTemplate实例化成功！");
  101.         RedisTemplate redisTemplate = new RedisTemplate();
  102.         initDomainRedisTemplate(redisTemplate, redisConnectionFactory);
  103.         return redisTemplate;
  104.     }
  106.     /**
  107.      * @auther: zhangyingqi
  108.      * @date: 17:52 2018/8/28
  109.      * @param: []
  110.      * @return: org.springframework.data.redis.serializer.RedisSerializer
  111.      * @Description: 引入自定义序列化
  112.      */
  113.     @Bean
  114.     public RedisSerializer fastJson2JsonRedisSerializer() {
  115.         return new FastJson2JsonRedisSerializer<Object>(Object.class);
  116.     }
  118.     /**
  119.      * @auther: zhangyingqi
  120.      * @date: 17:51 2018/8/28
  121.      * @param: [redisTemplate, factory]
  122.      * @return: void
  123.      * @Description: 设置数据存入 redis 的序列化方式,并开启事务
  124.      */
  125.     private void initDomainRedisTemplate(RedisTemplate redisTemplate, RedisConnectionFactory factory) {
  126.         //如果不配置Serializer，那么存储的时候缺省使用String，如果用User类型存储，那么会提示错误User can't cast to String！
  127.         redisTemplate.setKeySerializer(new StringRedisSerializer());
  128.         redisTemplate.setHashKeySerializer(new StringRedisSerializer());
  129.         redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
  130.         redisTemplate.setValueSerializer(fastJson2JsonRedisSerializer());
  131.         // 开启事务
  132.         redisTemplate.setEnableTransactionSupport(true);
  133.         redisTemplate.setConnectionFactory(factory);
  134.     }
  136.     /**
  137.      * @auther: zhangyingqi
  138.      * @date: 17:51 2018/8/28
  139.      * @param: [redisTemplate]
  140.      * @return: com.springboot.demo.base.utils.RedisUtil
  141.      * @Description: 注入封装RedisTemplate
  142.      */
  143.     @Bean(name = "redisUtil")
  144.     public RedisUtil redisUtil(RedisTemplate redisTemplate) {
  145.         log.info("RedisUtil注入成功！");
  146.         RedisUtil redisUtil = new RedisUtil();
  147.         redisUtil.setRedisTemplate(redisTemplate);
  148.         return redisUtil;
  149.     }
  151. }

3.然后补充其他依赖，为了实现分库存储，我们必须重写自带的RedisTemplate。

该类继承了springdataredis的RedisTemplate类，我们加入indexdb为Redis库的编号，重写了里面的RedisConnection方法，加入是否有库值传递进来的逻辑判断。

  1. package com.springboot.demo.base.utils;
  3. import org.springframework.data.redis.connection.RedisConnection;
  4. import org.springframework.data.redis.connection.jedis.JedisConnection;
  6. /**
  7.  * @ClassName: RedisTemplate
  8.  * @Auther: zhangyingqi
  9.  * @Date: 2018/8/28 16:15
  10.  * @Description: 重写RedisTemplate,加入选库
  11.  */
  12. public class RedisTemplate extends org.springframework.data.redis.core.RedisTemplate {
  14.     public static ThreadLocal<Integer> indexdb = new ThreadLocal<Integer>(){
  15.         @Override protected Integer initialValue() { return 0; }
  16.     };
  18.     @Override
  19.     protected RedisConnection preProcessConnection(RedisConnection connection, boolean existingConnection) {
  20.         try {
  21.             Integer dbIndex = indexdb.get();
  22.             //如果设置了dbIndex
  23.             if (dbIndex != null) {
  24.                 if (connection instanceof JedisConnection) {
  25.                     if (((JedisConnection) connection).getNativeConnection().getDB().intValue() != dbIndex) {
  26.                         connection.select(dbIndex);
  27.                     }
  28.                 } else {
  29.                     connection.select(dbIndex);
  30.                 }
  31.             } else {
  32.                 connection.select(0);
  33.             }
  34.         } finally {
  35.             indexdb.remove();
  36.         }
  37.         return super.preProcessConnection(connection, existingConnection);
  38.     }
  41. }

4.接下来还需要一个序列化操作类，帮助我们完成redis值的序列化。

添加FastJson2JsonRedisSerializer.java，实现RedisSerializer接口，实现其中的序列化和反序列化方法。

  1. package com.springboot.demo.base.utils;
  3. import com.alibaba.fastjson.JSON;
  4. import com.alibaba.fastjson.serializer.SerializerFeature;
  5. import org.springframework.data.redis.serializer.RedisSerializer;
  6. import org.springframework.data.redis.serializer.SerializationException;
  8. import java.nio.charset.Charset;
  10. /**
  11.  * @ClassName: FastJson2JsonRedisSerializer
  12.  * @Auther: zhangyingqi
  13.  * @Date: 2018/8/28 16:11
  14.  * @Description: 自定义序列化
  15.  */
  16. public class FastJson2JsonRedisSerializer<T> implements RedisSerializer<T> {
  18.     public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
  20.     private Class<T> clazz;
  22.     public FastJson2JsonRedisSerializer(Class<T> clazz) {
  23.         super(); this.clazz = clazz;
  24.     }
  26.         @Override
  27.         public byte[] serialize(T t) throws SerializationException {
  28.         if (t == null) {
  29.             return new byte[0];
  30.         }
  31.         return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
  32.     }
  34.         @Override
  35.         public T deserialize(byte[] bytes) throws SerializationException {
  36.         if (bytes == null || bytes.length <= 0) {
  37.             return null;
  38.         }
  39.         String str = new String(bytes, DEFAULT_CHARSET);
  40.         return (T) JSON.parseObject(str, clazz);
  41.     }
  42. }

5.添加RedisUtil.java，这就是最后实际操作中调用的redis操作工具类。

其中内容不具备分库操作的，所以我对其进行了改造，使得最终我们可以根据需要向不同的库中存储数据。

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

具体的改造过程示例：

  1.     public boolean set(String key,Object value,int indexdb) {
  2.         try {
  3.             redisTemplate.indexdb.set(indexdb);
  4.             redisTemplate.opsForValue().set(key, value);
  5.             return true;
  6.         } catch (Exception e) {
  7.             e.printStackTrace();
  8.             return false;
  9.         }
  11.     }

这是一个最基本的set方法，加入int型的indexdb参数，用来接收库编号，通过redisTemplate.indexdb.set(indexdb);完成选库操作，由于我们在内部使用finally清除了选库，所以不必担心下次操作库的缓存问题。

依次在你需要改造的地方做对应的修改即可。

二、实际操作示例

我这里直接拿现成的controller做演示，不再独立编写测试类

新建RedisTestController.java

  1. package com.springboot.demo.controller;
  3. import com.springboot.demo.base.controller.BaseController;
  4. import com.springboot.demo.base.utils.RedisConstants;
  5. import com.springboot.demo.base.utils.RedisUtil;
  6. import com.springboot.demo.base.utils.StateParameter;
  7. import com.springboot.demo.entity.User;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.stereotype.Controller;
  10. import org.springframework.ui.ModelMap;
  11. import org.springframework.web.bind.annotation.RequestMapping;
  12. import org.springframework.web.bind.annotation.ResponseBody;
  14. /**
  15.  * @ClassName: RedisTestController
  16.  * @Auther: zhangyingqi
  17.  * @Date: 2018/8/28 17:24
  18.  * @Description:
  19.  */
  20. @Controller
  21. @RequestMapping("/redis")
  22. public class RedisTestController extends BaseController{
  24.     @Autowired
  25.     RedisUtil redisUtil;
  27.     /**
  28.      * @auther: zhangyingqi
  29.      * @date: 17:26 2018/8/28
  30.      * @param: []
  31.      * @return: org.springframework.ui.ModelMap
  32.      * @Description: 测试redis存储&读取
  33.      */
  34.     @RequestMapping(value="/test")
  35.     @ResponseBody
  36.     public ModelMap test(){
  37.         try {
  38.             redisUtil.set("redisTemplate","这是一条测试数据", RedisConstants.datebase2);
  39.             String value = redisUtil.get("redisTemplate",RedisConstants.datebase2).toString();
  40.             logger.info("redisValue="+value);
  41.             logger.info("读取redis成功");
  42.             return getModelMap(StateParameter.SUCCESS, value, "操作成功");
  43.         } catch (Exception e) {
  44.             e.printStackTrace();
  45.             return getModelMap(StateParameter.FAULT, null, "操作失败");
  46.         }
  47.     }
  49.     @RequestMapping(value="/setUser")
  50.     @ResponseBody
  51.     public ModelMap setUser(){
  52.         try {
  53.             User user = new User();
  54.             user.setName("隔壁老王");
  55.             user.setAge(28);
  56.             user.setId(getUuid());
  57.             redisUtil.set("user",user, RedisConstants.datebase1);
  58.             User res = (User)redisUtil.get("user",RedisConstants.datebase1);
  59.             logger.info("res="+res.toString());
  60.             logger.info("读取redis成功");
  61.             return getModelMap(StateParameter.SUCCESS, res, "操作成功");
  62.         } catch (Exception e) {
  63.             e.printStackTrace();
  64.             return getModelMap(StateParameter.FAULT, null, "操作失败");
  65.         }
  66.     }
  68. }

这里使用@Autowired注入RedisUtil

  1.     @Autowired
  2.     RedisUtil redisUtil;

使用以下语句将字符串存入redis的库2中

  1. redisUtil.set("redisTemplate","这是一条测试数据", RedisConstants.datebase2);

启动项目执行操作，后台可以看到实例化成功

70 1

输入测试地址：http://localhost:8080/redis/test，返回成功，打开redis客户端工具，可以看到在db2中存入了该数据

70 2

最后给出pom包

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  6.     <groupId>com.springboot</groupId>
  7.     <artifactId>springbootRedis</artifactId>
  8.     <version>0.0.1-SNAPSHOT</version>
  9.     <packaging>war</packaging>
  11.     <name>springbootRedis</name>
  12.     <description>Demo project for Spring Boot</description>
  14.     <parent>
  15.         <groupId>org.springframework.boot</groupId>
  16.         <artifactId>spring-boot-starter-parent</artifactId>
  17.         <version>2.0.4.RELEASE</version>
  18.         <relativePath/> <!-- lookup parent from repository -->
  19.     </parent>
  21.     <properties>
  22.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  23.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  24.         <java.version>1.8</java.version>
  25.     </properties>
  27.     <dependencies>
  28.         <dependency>
  29.             <groupId>org.springframework.boot</groupId>
  30.             <artifactId>spring-boot-starter-tomcat</artifactId>
  31.             <!--<scope>provided</scope>-->
  32.         </dependency>
  33.         <dependency>
  34.             <groupId>org.springframework.boot</groupId>
  35.             <artifactId>spring-boot-starter-data-jpa</artifactId>
  36.             <exclusions>
  37.                 <exclusion>
  38.                     <groupId>org.hibernate</groupId>
  39.                     <artifactId>hibernate-entitymanager</artifactId>
  40.                 </exclusion>
  41.                 <exclusion>
  42.                     <groupId>org.hibernate</groupId>
  43.                     <artifactId>hibernate-core</artifactId>
  44.                 </exclusion>
  45.             </exclusions>
  46.         </dependency>
  47.         <dependency>
  48.             <groupId>org.hibernate</groupId>
  49.             <artifactId>hibernate-core</artifactId>
  50.             <version>5.2.10.Final</version>
  51.         </dependency>
  52.         <dependency>
  53.             <groupId>org.springframework.boot</groupId>
  54.             <artifactId>spring-boot-starter-data-redis</artifactId>
  55.         </dependency>
  56.         <dependency>
  57.             <groupId>org.springframework.boot</groupId>
  58.             <artifactId>spring-boot-starter-mail</artifactId>
  59.         </dependency>
  60.         <dependency>
  61.             <groupId>org.springframework.boot</groupId>
  62.             <artifactId>spring-boot-starter-thymeleaf</artifactId>
  63.         </dependency>
  64.         <dependency>
  65.             <groupId>org.springframework.boot</groupId>
  66.             <artifactId>spring-boot-starter-web</artifactId>
  67.         </dependency>
  69.         <dependency>
  70.             <groupId>mysql</groupId>
  71.             <artifactId>mysql-connector-java</artifactId>
  72.             <scope>runtime</scope>
  73.         </dependency>
  74.         <dependency>
  75.             <groupId>org.projectlombok</groupId>
  76.             <artifactId>lombok</artifactId>
  77.             <optional>true</optional>
  78.         </dependency>
  79.         <dependency>
  80.             <groupId>org.springframework.boot</groupId>
  81.             <artifactId>spring-boot-starter-test</artifactId>
  82.             <scope>test</scope>
  83.         </dependency>
  84.         <dependency>
  85.             <groupId>redis.clients</groupId>
  86.             <artifactId>jedis</artifactId>
  87.             <version>2.9.0</version>
  88.         </dependency>
  89.         <dependency>
  90.             <groupId>commons-io</groupId>
  91.             <artifactId>commons-io</artifactId>
  92.             <version>2.6</version>
  93.         </dependency>
  94.         <dependency>
  95.             <groupId>com.alibaba</groupId>
  96.             <artifactId>fastjson</artifactId>
  97.             <version>1.2.38</version>
  98.         </dependency>
  99.     </dependencies>
  101.     <build>
  102.         <plugins>
  103.             <plugin>
  104.                 <groupId>org.springframework.boot</groupId>
  105.                 <artifactId>spring-boot-maven-plugin</artifactId>
  106.             </plugin>
  107.         </plugins>
  108.     </build>
  111. </project>

原文：https://blog.csdn.net/zhulier1124/article/details/82154937

GitHub地址：https://github.com/jwwam/springbootRedis.git

发表评论

表情：
评论列表 （有 0 条评论，1173人围观）

还没有评论，来说两句吧...

相关阅读