一、前言

上篇介绍了接口文档工具 Swagger 及项目监控工具 JavaMelody 的集成过程，使项目更加健壮。在 JAVA Web 项目某些场景中，我们需要用缓存解决如热点数据访问的性能问题，业界常用的中间件如 Memcached 、 Redis 等。相比 Memcached ，Redis 支持更丰富的数据结构。本篇将主要介绍在 Spring Boot 中集成 Redis 的过程。

二、集成 Redis

在 Spring Boot 中使用 Redis 有两种方式：

  • 基于 RedisTemplate 类，该类是 Spring Data 提供的工具，可以直接注入使用。
  • 基于 Jedis，Jedis 是 Redis 官方推荐的面向 JAVA 的客户端。

本文将介绍第一种使用方式。

2.1 引入依赖包

其实 Spring Boot 提供的父工程中已经包含了所依赖的 Redis jar 包，我们只需在相应模块引入即可。第一篇我们已经提到过 demo-common 层是公用组件层，那么 Redis 相关的声明及配置应该在该层定义。于是乎在 demo-common 层的 pom 文件中引入 Redis 的依赖包。

  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-data-redis</artifactId>
  4. </dependency>

2.2 RedisTemplate 的自动配置

其实我们现在就可以在项目中注入 RedisTemplate 并使用了，至于原因，首先看下「 RedisAutoConfiguration 」类的源码：

  1. @Configuration
  2. @ConditionalOnClass({RedisOperations.class})
  3. @EnableConfigurationProperties({RedisProperties.class})
  4. @Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})
  5. public class RedisAutoConfiguration {
  6.     public RedisAutoConfiguration() {
  7.     }
  9.     @Bean
  10.     @ConditionalOnMissingBean(
  11.         name = {"redisTemplate"}
  12.     )
  13.     public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
  14.         RedisTemplate<Object, Object> template = new RedisTemplate();
  15.         template.setConnectionFactory(redisConnectionFactory);
  16.         return template;
  17.     }
  19.     @Bean
  20.     @ConditionalOnMissingBean
  21.     public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
  22.         StringRedisTemplate template = new StringRedisTemplate();
  23.         template.setConnectionFactory(redisConnectionFactory);
  24.         return template;
  25.     }
  26. }

从源码可以看出，Spring Boot 会自动帮我们生成了一个 RedisTemplate 及一个 StringRedisTemplate ，但是这个 RedisTemplate 的泛型是 <Object, Object> ，如果我们直接使用就需要处理各种类型转换。所以为了方便使用，我们需要自定义一个泛型为 <String, Object> 的 RedisTemplate 。

而 @ConditionalOnMissingBean 注解的作用是在当前 Spring 上下文中不存在某个对象时，才会自动实例化一个 Bean 。因此我们可以自定义 RedisTemplate 从而替代默认的。

2.2 自定义 Redis 配置类

Spring Data 提供了若干个 Serializer ，主要包括：

  • JdkSerializationRedisSerializer — 使用 JAVA 自带的序列化机制将对象序列化为一个字符串
  • OxmSerializer — 将对象序列化为 XML 字符串
  • Jackson2JsonRedisSerializer — 将对象序列化为 JSON 字符串

其中 RedisTemplate 默认的序列化方式是 Jdk ，虽然是效率比较高但是序列化结果的字符串是最长的。而 JSON 由于其数据格式的紧凑型，序列化结果的字符串是最小的，即占用的内存最小。所以我们选择用 Jackson 替代默认的 Jdk 方式。

① 首先在项目父 pom 文件中定义 Jackson 的版本号且声明 Jackson 依赖。

  1. <properties>
  2.     ...省略其余部分...
  3.     <jackson.version>2.9.4</jackson.version>
  4. </properties>
  1. <dependencyManagement>
  2.     <dependencies>
  3.         ...省略其余部分...
  4.         <dependency>
  5.             <groupId>com.fasterxml.jackson.core</groupId>
  6.             <artifactId>jackson-databind</artifactId>
  7.             <version>${jackson.version}</version>
  8.         </dependency>
  9.         <dependency>
  10.             <groupId>com.fasterxml.jackson.datatype</groupId>
  11.             <artifactId>jackson-datatype-jsr310</artifactId>
  12.             <version>${jackson.version}</version>
  13.         </dependency>
  14.     </dependencies>
  15. </dependencyManagement>

② 其次在 demo-common 层的 pom 文件中添加上述 Jackson 依赖。

  1. <dependencies>
  2.     ...省略其余部分...
  3.     <dependency>
  4.         <groupId>com.fasterxml.jackson.core</groupId>
  5.         <artifactId>jackson-databind</artifactId>
  6.     </dependency>
  7.     <dependency>
  8.         <groupId>com.fasterxml.jackson.datatype</groupId>
  9.         <artifactId>jackson-datatype-jsr310</artifactId>
  10.     </dependency>
  11. </dependencies>

③ 最后在 demo-common 层创建 com.example.demo.common 包，添加 Redis 目录并在其中创建 RedisConfig 配置类。

  1. package com.example.demo.common.redis;
  3. import com.fasterxml.jackson.annotation.JsonAutoDetect;
  4. import com.fasterxml.jackson.annotation.PropertyAccessor;
  5. import com.fasterxml.jackson.databind.ObjectMapper;
  6. import com.fasterxml.jackson.databind.SerializationFeature;
  7. import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
  8. import org.springframework.context.annotation.Bean;
  9. import org.springframework.context.annotation.Configuration;
  10. import org.springframework.data.redis.connection.RedisConnectionFactory;
  11. import org.springframework.data.redis.core.RedisTemplate;
  12. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  13. import org.springframework.data.redis.serializer.StringRedisSerializer;
  15. /**
  16.  * @author linjian
  17.  * @date 2019/3/2
  18.  */
  19. @Configuration
  20. public class RedisConfig {
  22.     @Bean
  23.     @SuppressWarnings("all")
  24.     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
  25.         ObjectMapper objectMapper = new ObjectMapper();
  26.         objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  27.         objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  28.         objectMapper.registerModule(new JavaTimeModule());
  29.         objectMapper.findAndRegisterModules();
  30.         objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
  32.         // 使用 Jackson2JsonRedisSerialize 替换默认序列化
  33.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
  34.         jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
  36.         StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
  38.         RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
  39.         redisTemplate.setConnectionFactory(factory);
  40.         // key 采用 String 的序列化方式
  41.         redisTemplate.setKeySerializer(stringRedisSerializer);
  42.         // hash 的 key 也采用 String 的序列化方式
  43.         redisTemplate.setHashKeySerializer(stringRedisSerializer);
  44.         // value 序列化方式采用 jackson
  45.         redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
  46.         // hash 的 value 序列化方式采用 jackson
  47.         redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
  48.         redisTemplate.afterPropertiesSet();
  49.         return redisTemplate;
  50.     }
  51. }

2.3 自定义 Redis 工具类

直接使用 RedisTemplate 操作 Redis 需要很多额外的代码，最好封装成一个工具类，使用时直接注入。

① 定义一个常用的缓存时间常量类

  1. package com.example.demo.common.redis;
  3. /**
  4.  * @author linjian
  5.  * @date 2019/3/2
  6.  */
  7. public class CacheTime {
  9.     /**
  10.      * 缓存时效 5秒钟
  11.      */
  12.     public static int CACHE_EXP_FIVE_SECONDS = 5;
  14.     /**
  15.      * 缓存时效 1分钟
  16.      */
  17.     public static int CACHE_EXP_MINUTE = 60;
  19.     /**
  20.      * 缓存时效 5分钟
  21.      */
  22.     public static int CACHE_EXP_FIVE_MINUTES = 60 * 5;
  24.     /**
  25.      * 缓存时效 10分钟
  26.      */
  27.     public static int CACHE_EXP_TEN_MINUTES = 60 * 10;
  29.     /**
  30.      * 缓存时效 15分钟
  31.      */
  32.     public static int CACHE_EXP_QUARTER_MINUTES = 60 * 15;
  34.     /**
  35.      * 缓存时效 60分钟
  36.      */
  37.     public static int CACHE_EXP_HOUR = 60 * 60;
  39.     /**
  40.      * 缓存时效 12小时
  41.      */
  42.     public static int CACHE_EXP_HALF_DAY = 12 * 60 * 60;
  44.     /**
  45.      * 缓存时效 1天
  46.      */
  47.     public static int CACHE_EXP_DAY = 3600 * 24;
  49.     /**
  50.      * 缓存时效 1周
  51.      */
  52.     public static int CACHE_EXP_WEEK = 3600 * 24 * 7;
  54.     /**
  55.      * 缓存时效 1月
  56.      */
  57.     public static int CACHE_EXP_MONTH = 3600 * 24 * 30 * 7;
  59.     /**
  60.      * 缓存时效 永久
  61.      */
  62.     public static int CACHE_EXP_FOREVER = 0;
  63. }

② 定义工具类

  1. package com.example.demo.common.redis;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.data.redis.core.RedisTemplate;
  5. import org.springframework.stereotype.Component;
  6. import org.springframework.util.CollectionUtils;
  8. import java.util.List;
  9. import java.util.Map;
  10. import java.util.Set;
  11. import java.util.concurrent.TimeUnit;
  13. /**
  14.  * @author linjian
  15.  * @date 2019/3/2
  16.  */
  17. @Component
  18. public class RedisClient {
  20.     @Autowired
  21.     private RedisTemplate<String, Object> redisTemplate;
  23.     /**
  24.      * 指定缓存失效时间
  25.      *
  26.      * @param key  键
  27.      * @param time 时间(秒)
  28.      * @return
  29.      */
  30.     public boolean expire(String key, long time) {
  31.         try {
  32.             if (time > 0) {
  33.                 redisTemplate.expire(key, time, TimeUnit.SECONDS);
  34.             }
  35.             return true;
  36.         } catch (Exception e) {
  37.             e.printStackTrace();
  38.             return false;
  39.         }
  40.     }
  42.     /**
  43.      * 根据key 获取剩余过期时间
  44.      *
  45.      * @param key 键 不能为null
  46.      * @return 时间(秒) 返回0代表为永久有效
  47.      */
  48.     public long ttl(String key) {
  49.         return redisTemplate.getExpire(key, TimeUnit.SECONDS);
  50.     }
  52.     /**
  53.      * 判断key是否存在
  54.      *
  55.      * @param key 键
  56.      * @return true 存在 false不存在
  57.      */
  58.     public boolean exists(String key) {
  59.         try {
  60.             return redisTemplate.hasKey(key);
  61.         } catch (Exception e) {
  62.             e.printStackTrace();
  63.             return false;
  64.         }
  65.     }
  67.     /**
  68.      * 删除缓存
  69.      *
  70.      * @param key 可以传一个值 或多个
  71.      */
  72.     @SuppressWarnings("unchecked")
  73.     public void del(String... key) {
  74.         if (key != null && key.length > 0) {
  75.             if (key.length == 1) {
  76.                 redisTemplate.delete(key[0]);
  77.             } else {
  78.                 redisTemplate.delete(CollectionUtils.arrayToList(key));
  79.             }
  80.         }
  81.     }
  83.     /**
  84.      * 模糊匹配批量删除
  85.      *
  86.      * @param pattern 匹配的前缀
  87.      */
  88.     public void deleteByPattern(String pattern) {
  89.         Set<String> keys = redisTemplate.keys(pattern);
  90.         if (!CollectionUtils.isEmpty(keys)) {
  91.             redisTemplate.delete(keys);
  92.         }
  93.     }
  95.     /**
  96.      * 设置指定 key 的值
  97.      *
  98.      * @param key   键
  99.      * @param value 值
  100.      * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
  101.      * @return true成功 false 失败
  102.      */
  103.     public boolean set(String key, Object value, long time) {
  104.         try {
  105.             if (time == CacheTime.CACHE_EXP_FOREVER) {
  106.                 redisTemplate.opsForValue().set(key, value);
  107.             } else {
  108.                 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
  109.             }
  110.             return true;
  111.         } catch (Exception e) {
  112.             e.printStackTrace();
  113.             return false;
  114.         }
  115.     }
  117.     /**
  118.      * 获取指定 key 的值
  119.      *
  120.      * @param key 键
  121.      * @return 值
  122.      */
  123.     @SuppressWarnings("unchecked")
  124.     public <T> T get(String key) {
  125.         return key == null ? null : (T) redisTemplate.opsForValue().get(key);
  126.     }
  128.     /**
  129.      * 将 key 中储存的数字值递增
  130.      *
  131.      * @param key   键
  132.      * @param delta 要增加几(大于0)
  133.      * @return
  134.      */
  135.     public long incr(String key, long delta) {
  136.         if (delta <= 0) {
  137.             throw new IllegalArgumentException("递增因子必须大于0");
  138.         }
  139.         return redisTemplate.opsForValue().increment(key, delta);
  140.     }
  142.     /**
  143.      * 将 key 中储存的数字值递减
  144.      *
  145.      * @param key   键
  146.      * @param delta 要减少几(小于0)
  147.      * @return
  148.      */
  149.     public long decr(String key, long delta) {
  150.         if (delta <= 0) {
  151.             throw new IllegalArgumentException("递减因子必须大于0");
  152.         }
  153.         return redisTemplate.opsForValue().increment(key, -delta);
  154.     }
  156.     /**
  157.      * 将哈希表 key 中的字段 field 的值设为 value
  158.      *
  159.      * @param key   键
  160.      * @param field 字段
  161.      * @param value 值
  162.      * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
  163.      * @return true 成功 false失败
  164.      */
  165.     public boolean hset(String key, String field, Object value, long time) {
  166.         try {
  167.             redisTemplate.opsForHash().put(key, field, value);
  168.             if (time != CacheTime.CACHE_EXP_FOREVER) {
  169.                 expire(key, time);
  170.             }
  171.             return true;
  172.         } catch (Exception e) {
  173.             e.printStackTrace();
  174.             return false;
  175.         }
  176.     }
  178.     /**
  179.      * 同时将多个 field-value (域-值)对设置到哈希表 key 中
  180.      *
  181.      * @param key  键
  182.      * @param map  对应多个键值
  183.      * @param time 时间(秒)
  184.      * @return true成功 false失败
  185.      */
  186.     public boolean hmset(String key, Map<String, Object> map, long time) {
  187.         try {
  188.             redisTemplate.opsForHash().putAll(key, map);
  189.             if (time != CacheTime.CACHE_EXP_FOREVER) {
  190.                 expire(key, time);
  191.             }
  192.             return true;
  193.         } catch (Exception e) {
  194.             e.printStackTrace();
  195.             return false;
  196.         }
  197.     }
  199.     /**
  200.      * 删除一个或多个哈希表字段
  201.      *
  202.      * @param key   键
  203.      * @param field 字段 可以多个
  204.      */
  205.     public void hdel(String key, Object... field) {
  206.         redisTemplate.opsForHash().delete(key, field);
  207.     }
  209.     /**
  210.      * 获取存储在哈希表中指定字段的值
  211.      *
  212.      * @param key   键
  213.      * @param field 字段
  214.      * @return 值
  215.      */
  216.     public <T> T hget(String key, String field) {
  217.         return (T) redisTemplate.opsForHash().get(key, field);
  218.     }
  220.     /**
  221.      * 获取在哈希表中指定 key 的所有字段和值
  222.      *
  223.      * @param key 键
  224.      * @return 对应的多个键值
  225.      */
  226.     public Map<Object, Object> hmget(String key) {
  227.         return redisTemplate.opsForHash().entries(key);
  228.     }
  230.     /**
  231.      * 查看哈希表 key 中，指定的字段是否存在
  232.      *
  233.      * @param key   键
  234.      * @param field 字段
  235.      * @return true 存在 false不存在
  236.      */
  237.     public boolean hexists(String key, String field) {
  238.         return redisTemplate.opsForHash().hasKey(key, field);
  239.     }
  241.     /**
  242.      * 获取哈希表中字段的数量
  243.      *
  244.      * @param key 键
  245.      * @return 字段数量
  246.      */
  247.     public long hlen(String key) {
  248.         try {
  249.             return redisTemplate.opsForHash().size(key);
  250.         } catch (Exception e) {
  251.             e.printStackTrace();
  252.             return 0L;
  253.         }
  254.     }
  256.     /**
  257.      * 向集合添加一个或多个成员
  258.      *
  259.      * @param key    键
  260.      * @param time   时间(秒)
  261.      * @param values 成员 可以是多个
  262.      * @return 成功个数
  263.      */
  264.     public long sadd(String key, long time, Object... values) {
  265.         try {
  266.             Long count = redisTemplate.opsForSet().add(key, values);
  267.             if (time != CacheTime.CACHE_EXP_FOREVER) {
  268.                 expire(key, time);
  269.             }
  270.             return count;
  271.         } catch (Exception e) {
  272.             e.printStackTrace();
  273.             return 0L;
  274.         }
  275.     }
  277.     /**
  278.      * 移除集合中一个或多个成员
  279.      *
  280.      * @param key    键
  281.      * @param values 成员 可以是多个
  282.      * @return 移除的个数
  283.      */
  284.     public long srem(String key, Object... values) {
  285.         try {
  286.             return redisTemplate.opsForSet().remove(key, values);
  287.         } catch (Exception e) {
  288.             e.printStackTrace();
  289.             return 0L;
  290.         }
  291.     }
  293.     /**
  294.      * 返回集合中的所有成员
  295.      *
  296.      * @param key 键
  297.      * @return 成员列表
  298.      */
  299.     public <T> Set<T> smembers(String key) {
  300.         try {
  301.             return (Set<T>) redisTemplate.opsForSet().members(key);
  302.         } catch (Exception e) {
  303.             e.printStackTrace();
  304.             return null;
  305.         }
  306.     }
  308.     /**
  309.      * 判断 member 元素是否是集合 key 的成员
  310.      *
  311.      * @param key    键
  312.      * @param member 成员
  313.      * @return true 存在 false不存在
  314.      */
  315.     public boolean sismember(String key, Object member) {
  316.         try {
  317.             return redisTemplate.opsForSet().isMember(key, member);
  318.         } catch (Exception e) {
  319.             e.printStackTrace();
  320.             return false;
  321.         }
  322.     }
  324.     /**
  325.      * 获取集合的成员数
  326.      *
  327.      * @param key 键
  328.      * @return 成员数
  329.      */
  330.     public long slen(String key) {
  331.         try {
  332.             return redisTemplate.opsForSet().size(key);
  333.         } catch (Exception e) {
  334.             e.printStackTrace();
  335.             return 0L;
  336.         }
  337.     }
  339.     /**
  340.      * 在列表头部添加一个值
  341.      *
  342.      * @param key   键
  343.      * @param value 值
  344.      * @param time  时间(秒)
  345.      * @return boolean
  346.      */
  347.     public boolean lpush(String key, Object value, long time) {
  348.         try {
  349.             redisTemplate.opsForList().leftPush(key, value);
  350.             if (time != CacheTime.CACHE_EXP_FOREVER) {
  351.                 expire(key, time);
  352.             }
  353.             return true;
  354.         } catch (Exception e) {
  355.             e.printStackTrace();
  356.             return false;
  357.         }
  358.     }
  360.     /**
  361.      * 在列表头部添加多个值
  362.      *
  363.      * @param key    键
  364.      * @param values 值
  365.      * @param time   时间(秒)
  366.      * @return boolean
  367.      */
  368.     public boolean lpush(String key, List<Object> values, long time) {
  369.         try {
  370.             redisTemplate.opsForList().leftPushAll(key, values);
  371.             if (time != CacheTime.CACHE_EXP_FOREVER) {
  372.                 expire(key, time);
  373.             }
  374.             return true;
  375.         } catch (Exception e) {
  376.             e.printStackTrace();
  377.             return false;
  378.         }
  379.     }
  381.     /**
  382.      * 在列表尾部添加一个值
  383.      *
  384.      * @param key   键
  385.      * @param value 值
  386.      * @param time  时间(秒)
  387.      * @return boolean
  388.      */
  389.     public boolean rpush(String key, Object value, long time) {
  390.         try {
  391.             redisTemplate.opsForList().rightPush(key, value);
  392.             if (time != CacheTime.CACHE_EXP_FOREVER) {
  393.                 expire(key, time);
  394.             }
  395.             return true;
  396.         } catch (Exception e) {
  397.             e.printStackTrace();
  398.             return false;
  399.         }
  400.     }
  402.     /**
  403.      * 在列表尾部添加多个值
  404.      *
  405.      * @param key    键
  406.      * @param values 值
  407.      * @param time   时间(秒)
  408.      * @return boolean
  409.      */
  410.     public boolean rpush(String key, List<Object> values, long time) {
  411.         try {
  412.             redisTemplate.opsForList().rightPushAll(key, values);
  413.             if (time != CacheTime.CACHE_EXP_FOREVER) {
  414.                 expire(key, time);
  415.             }
  416.             return true;
  417.         } catch (Exception e) {
  418.             e.printStackTrace();
  419.             return false;
  420.         }
  421.     }
  423.     /**
  424.      * 移除列表元素
  425.      *
  426.      * @param key   键
  427.      * @param count 移除多少个
  428.      * @param value 值
  429.      * @return 移除的个数
  430.      */
  431.     public long lrem(String key, long count, Object value) {
  432.         try {
  433.             return redisTemplate.opsForList().remove(key, count, value);
  434.         } catch (Exception e) {
  435.             e.printStackTrace();
  436.             return 0;
  437.         }
  438.     }
  440.     /**
  441.      * 通过索引设置列表元素的值
  442.      *
  443.      * @param key   键
  444.      * @param index 索引
  445.      * @param value 值
  446.      * @return boolean
  447.      */
  448.     public boolean lset(String key, long index, Object value) {
  449.         try {
  450.             redisTemplate.opsForList().set(key, index, value);
  451.             return true;
  452.         } catch (Exception e) {
  453.             e.printStackTrace();
  454.             return false;
  455.         }
  456.     }
  458.     /**
  459.      * 获取列表指定范围内的元素
  460.      *
  461.      * @param key   键
  462.      * @param start 开始
  463.      * @param end   结束 0 到 -1代表所有值
  464.      * @return 元素列表
  465.      */
  466.     @SuppressWarnings("unchecked")
  467.     public <T> List<T> lrange(String key, long start, long end) {
  468.         try {
  469.             return (List<T>) redisTemplate.opsForList().range(key, start, end);
  470.         } catch (Exception e) {
  471.             e.printStackTrace();
  472.             return null;
  473.         }
  474.     }
  476.     /**
  477.      * 通过索引获取列表中的元素
  478.      *
  479.      * @param key   键
  480.      * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
  481.      * @return
  482.      */
  483.     public Object lindex(String key, long index) {
  484.         try {
  485.             return redisTemplate.opsForList().index(key, index);
  486.         } catch (Exception e) {
  487.             e.printStackTrace();
  488.             return null;
  489.         }
  490.     }
  492.     /**
  493.      * 获取列表长度
  494.      *
  495.      * @param key 键
  496.      * @return 列表长度
  497.      */
  498.     public long llen(String key) {
  499.         try {
  500.             return redisTemplate.opsForList().size(key);
  501.         } catch (Exception e) {
  502.             e.printStackTrace();
  503.             return 0L;
  504.         }
  505.     }
  507.     /**
  508.      * 向有序集合添加一个成员，或者更新已存在成员的分数
  509.      *
  510.      * @param key    键
  511.      * @param time   时间(秒)
  512.      * @param member 成员
  513.      * @param score  分数
  514.      * @return
  515.      */
  516.     public boolean zadd(String key, long time, Object member, double score) {
  517.         try {
  518.             boolean ret = redisTemplate.opsForZSet().add(key, member, score);
  519.             if (time != CacheTime.CACHE_EXP_FOREVER) {
  520.                 expire(key, time);
  521.             }
  522.             return ret;
  523.         } catch (Exception e) {
  524.             e.printStackTrace();
  525.             return false;
  526.         }
  527.     }
  529.     /**
  530.      * 移除有序集合中的一个或多个成员
  531.      *
  532.      * @param key    键
  533.      * @param values 值 可以是多个
  534.      * @return 移除的个数
  535.      */
  536.     public long zrem(String key, Object... values) {
  537.         try {
  538.             return redisTemplate.opsForZSet().remove(key, values);
  539.         } catch (Exception e) {
  540.             e.printStackTrace();
  541.             return 0L;
  542.         }
  543.     }
  545.     /**
  546.      * 通过索引区间返回有序集合成指定区间内的成员 分数从低到高
  547.      *
  548.      * @param key   键
  549.      * @param start 开始
  550.      * @param end   结束 0 到 -1代表所有值
  551.      * @return 成员集合
  552.      */
  553.     public Set<Object> zrange(String key, long start, long end) {
  554.         try {
  555.             return redisTemplate.opsForZSet().range(key, start, end);
  556.         } catch (Exception e) {
  557.             e.printStackTrace();
  558.             return null;
  559.         }
  560.     }
  562.     /**
  563.      * 通过索引区间返回有序集合成指定区间内的成员 分数从高到低
  564.      *
  565.      * @param key   键
  566.      * @param start 开始
  567.      * @param end   结束 0 到 -1代表所有值
  568.      * @return 成员集合
  569.      */
  570.     public Set<Object> zrevrange(String key, long start, long end) {
  571.         try {
  572.             return redisTemplate.opsForZSet().range(key, start, end);
  573.         } catch (Exception e) {
  574.             e.printStackTrace();
  575.             return null;
  576.         }
  577.     }
  579.     /**
  580.      * 返回有序集合中某个成员的分数值
  581.      *
  582.      * @param key    键
  583.      * @param member 成员
  584.      * @return 分数值
  585.      */
  586.     public double zscore(String key, Object member) {
  587.         try {
  588.             return redisTemplate.opsForZSet().score(key, member);
  589.         } catch (Exception e) {
  590.             e.printStackTrace();
  591.             return 0.0;
  592.         }
  593.     }
  595.     /**
  596.      * 判断有序集合中某个成员是否存在
  597.      *
  598.      * @param key    键
  599.      * @param member 成员
  600.      * @return true 存在 false不存在
  601.      */
  602.     public boolean zexist(String key, Object member) {
  603.         try {
  604.             return null != redisTemplate.opsForZSet().score(key, member);
  605.         } catch (Exception e) {
  606.             e.printStackTrace();
  607.             return false;
  608.         }
  609.     }
  611.     /**
  612.      * 获取有序集合的成员数
  613.      *
  614.      * @param key 键
  615.      * @return 成员数
  616.      */
  617.     public long zlen(String key) {
  618.         try {
  619.             return redisTemplate.opsForZSet().size(key);
  620.         } catch (Exception e) {
  621.             e.printStackTrace();
  622.             return 0L;
  623.         }
  624.     }
  625. }

2.4 添加 Redis 常用配置项

在 application.properties 文件中的添加 Redis 相关的配置项：

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

2.5 Redis 缓存测试

① 首先在 DemoService 中注入 RedisClient ，修改 test 方法将 user 对象以 user:1 为键存放到 Redis 中。

Redis 开发规范：https://yq.aliyun.com/articles/531067

  1. package com.example.demo.biz.service.impl;
  3. import com.example.demo.biz.service.DemoService;
  4. import com.example.demo.common.redis.CacheTime;
  5. import com.example.demo.common.redis.RedisClient;
  6. import com.example.demo.dao.entity.UserDO;
  7. import com.example.demo.dao.mapper.business.UserMapper;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.stereotype.Service;
  11. /**
  12.  * @author linjian
  13.  * @date 2019/1/15
  14.  */
  15. @Service
  16. public class DemoServiceImpl implements DemoService {
  18.     @Autowired
  19.     private UserMapper userMapper;
  21.     @Autowired
  22.     private RedisClient redisClient;
  24.     @Override
  25.     public String test() {
  26.         UserDO user = userMapper.selectById(1);
  27.         redisClient.set("user:1", user, CacheTime.CACHE_EXP_FIVE_MINUTES);
  28.         return user.toString();
  29.     }
  30. }

② 之后使用 Redis Desktop Manager 客户端连接 Redis 服务器，选择数据库「 1 」，查看刚存放的缓存。

三、结语

至此 Spring Boot 集成 Redis 的具体步骤介绍完毕，我们自定义了 Redis 的序列化方式，并通过一个简单的例子测试了 Redis 的可用性，相关代码已同步至 GitHub 。

Spring Boot 项目实战（四）集成 Redis的更多相关文章

  1. Spring Boot 项目实战（五）集成 Dubbo

    一.前言 上篇介绍了 Redis 的集成过程,可用于解决热点数据访问的性能问题.随着业务复杂度的提高,单体应用越来越庞大,就好比一个类的代码行数越来越多,分而治之,切成多个类应该是更好的解决方法,所以 ...

  2. Spring Boot 项目学习 (四) Spring Boot整合Swagger2自动生成API文档

    0 引言 在做服务端开发的时候,难免会涉及到API 接口文档的编写,可以经历过手写API 文档的过程,就会发现,一个自动生成API文档可以提高多少的效率. 以下列举几个手写API 文档的痛点: 文档需 ...

  3. Spring Boot 1.5.4集成Redis

    本文示例源码,请看这里: 如何安装与配置Redis,请看这里 首先添加起步依赖: <dependency> <groupId>org.springframework.boot& ...

  4. Spring Boot 项目实战（六）集成 Apollo

    一.前言 上篇介绍了 Spring Boot 集成 Dubbo,使我们的系统打下了分布式的基础.随着程序功能的日益复杂,程序的配置日益增多:各种功能开关.参数配置.服务器地址等:对程序配置的期望值也越 ...

  5. Spring Boot 项目实战（三）集成 Swagger 及 JavaMelody

    一.前言 上篇介绍了 Logback 的集成过程,总体已经达到了基本可用的项目结构.本篇主要介绍两个常用工具,接口文档工具 Swagger .项目监控工具 JavaMelody 的集成步骤. 二.Sw ...

  6. spring boot 学习(十四)SpringBoot+Redis+SpringSession缓存之实战

    SpringBoot + Redis +SpringSession 缓存之实战 前言 前几天,从师兄那儿了解到EhCache是进程内的缓存框架,虽然它已经提供了集群环境下的缓存同步策略,这种同步仍然需 ...

  7. Spring Boot 项目实战（二）集成 Logback

    一.前言 上篇介绍了 Spring Boot Maven 多模块项目的搭建方法以及 MyBatis 的集成.通常在调试接口或者排查问题时我们主要借助于日志,一个设计合理的日志文件配置能大大降低我们的排 ...

  8. Spring Boot 2 实战：利用Redis的Geo功能实现查找附近的位置

    1. 前言 老板突然要上线一个需求,获取当前位置方圆一公里的业务代理点.明天上线!当接到这个需求的时候我差点吐血,这时间也太紧张了.赶紧去查相关的技术选型.经过一番折腾,终于在晚上十点完成了这个需求. ...

  9. Spring Boot 项目实战（一）Maven 多模块项目搭建

    一.前言 最近公司项目准备开始重构,框架选定为 Spring Boot ,本篇主要记录了在 IDEA 中搭建 Spring Boot Maven 多模块项目的过程. 二.软件及硬件环境 macOS S ...

随机推荐

  1. Linux Oracle bash: “sqlplus / as sysdba”: command not found 解决方法

    bash: sqlplus: command not found 解决方法 注:本文来源于 <   bash: sqlplus: command not found 解决方法   > 1: ...

  2. nginx实践(二)之静态资源web服务(浏览器缓存场景）

    配置语法-expires

  3. PHP中json_encode()使用须知，JSON数组和JSON对象

    ⊰ 偷偷的告诉你,这是一个很不谨慎就会踩得坑 ⊱  如下代码 (看了一下很简单,没毛病啊,老铁) $arr = array( '0'=>'a','1'=>'b','2'=>'c',' ...

  4. python并发编程之多线程1

    一多线程的概念介绍 threading模块介绍 threading模块和multiprocessing模块在使用层面,有很大的相似性. 二.开启多线程的两种方式 1.创建线程的开销比创建进程的开销小, ...

  5. LeetCode（109）：有序链表转换二叉搜索树

    Medium! 题目描述: 给定一个单链表,其中的元素按升序排序,将其转换为高度平衡的二叉搜索树. 本题中,一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1. 示例: ...

  6. Go如何正确的使用mysql driver

    具体文章查看: https://xiequan.info/go%E5%A6%82%E4%BD%95%E6%AD%A3%E7%A1%AE%E7%9A%84%E4%BD%BF%E7%94%A8mysql- ...

  7. windows 7 下用git

    参考:http://my.oschina.net/longxuu/blog/141699

  8. 关于HTML或JS加密解密的七种方式

    本文一共介绍了七种方法:   一:最简单的加密解密   二:转义字符""的妙用   三:使用Microsoft出品的脚本编码器Script Encoder来进行编码    (自创简 ...

  9. 插件使用一表单验证一validation

    jquery-validation是一款前端经验js插件,可以验证必填字段.邮件.URL.数字范围等,在表单中应用非常广泛. 官方网站 https://jqueryvalidation.org/ 源码 ...

  10. error: each element of 'ext_modules' option must be an Extension instance or 2-tuple

    在编译cython扩展时出现. 解决办法: 必须先import setup再import extension,否则报错 from setuptools import setup from distut ...