SpringBoot2.x 整合Redis实现缓存，自定义序列化和设置过期时间

avatar 2019年01月18日22:24:08 6 21808 views
博主分享免费Java教学视频，B站账号：Java刘哥 ，长期提供技术问题解决、项目定制：本站商品点此
SpringBoot2.x和1.x的区别很大，比如在整合 Redis 这一块，RedisCacheManager就有不同。

本文介绍 SpringBoot 2.0.5版本 整合 Redis。


一、基本配置

  1. pom.xml
  1. <!-- 里面依赖了spring-data-redis -->
  2.     <dependency>
  3.       <groupId>org.springframework.boot</groupId>
  4.       <artifactId>spring-boot-starter-data-redis</artifactId>
  5.     </dependency>



2.RedisConfig.java
  1. package com.liuyanzhao.sens.config;
  3. import lombok.extern.slf4j.Slf4j;
  4. import org.springframework.cache.annotation.EnableCaching;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  7. import org.springframework.data.redis.cache.RedisCacheConfiguration;
  8. import org.springframework.data.redis.cache.RedisCacheManager;
  9. import org.springframework.data.redis.connection.RedisConnectionFactory;
  10. import org.springframework.data.redis.core.RedisTemplate;
  11. import org.springframework.data.redis.serializer.*;
  13. import java.time.Duration;
  15. /**
  16.  * @author 言曌
  17.  * @date 2018/5/21 上午10:02
  18.  */
  19. @Configuration
  20. @EnableCaching
  21. @Slf4j
  22. public class RedisConfig {
  25.     //过期时间1天
  26.     private Duration timeToLive = Duration.ofDays(1);
  29.     @Bean
  30.     public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
  31.         //默认1
  32.         RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
  33.                 .entryTtl(this.timeToLive)
  34.                 .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(keySerializer()))
  35.                 .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(valueSerializer()))
  36.                 .disableCachingNullValues();
  38.         RedisCacheManager redisCacheManager = RedisCacheManager.builder(connectionFactory)
  39.                 .cacheDefaults(config)
  40.                 .transactionAware()
  41.                 .build();
  43.         log.debug("自定义RedisCacheManager加载完成");
  44.         return redisCacheManager;
  45.     }
  47.     @Bean(name = "redisTemplate")
  48.     public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
  49.         RedisTemplate<String,Object> redisTemplate = new RedisTemplate<>();
  50.         redisTemplate.setConnectionFactory(redisConnectionFactory);
  52.         redisTemplate.setKeySerializer(keySerializer());
  53.         redisTemplate.setHashKeySerializer(keySerializer());
  54.         redisTemplate.setValueSerializer(valueSerializer());
  55.         redisTemplate.setHashValueSerializer(valueSerializer());
  57.         log.debug("自定义RedisTemplate加载完成");
  58.         return redisTemplate;
  59.     }
  61.     private RedisSerializer<String> keySerializer() {
  62.         return new StringRedisSerializer();
  63.     }
  65.     private RedisSerializer<Object> valueSerializer() {
  66.         return new GenericJackson2JsonRedisSerializer();
  67.     }
  68. }

设置默认过期时间1天

GenericJackson2JsonRedisSerializer序列化value是采用json格式，里面有对象的class名称，便于反序列化。


二、@Cacheable和@CacheEvict 的使用


以友情链接的service实现为例
  1. package com.liuyanzhao.sens.service.impl;
  3. import com.liuyanzhao.sens.entity.Link;
  4. import com.liuyanzhao.sens.mapper.LinkMapper;
  5. import com.liuyanzhao.sens.service.LinkService;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.cache.annotation.CacheEvict;
  8. import org.springframework.cache.annotation.Cacheable;
  9. import org.springframework.stereotype.Service;
  11. import java.util.List;
  13. /**
  14.  * <pre>
  15.  *     友情链接业务逻辑实现类
  16.  * </pre>
  17.  *
  18.  * @author : saysky
  19.  * @date : 2017/11/14
  20.  */
  21. @Service
  22. public class LinkServiceImpl implements LinkService {
  24.     private static final String LINKS_CACHE_NAME = "links";
  26.     @Autowired(required = false)
  27.     private LinkMapper linkMapper;
  29.     @Override
  30.     @CacheEvict(value = LINKS_CACHE_NAME, allEntries = true, beforeInvocation = true)
  31.     public Link saveByLink(Link link) {
  32.         if (link != null && link.getLinkId() != null) {
  33.             linkMapper.updateById(link);
  34.         } else {
  35.             linkMapper.insert(link);
  36.         }
  37.         return link;
  38.     }
  40.     @Override
  41.     @CacheEvict(value = LINKS_CACHE_NAME, allEntries = true, beforeInvocation = true)
  42.     public void removeByLinkId(Long linkId) {
  43.         linkMapper.deleteById(linkId);
  44.     }
  46.     @Override
  47.     @Cacheable(value = LINKS_CACHE_NAME, key = "'links_all'")
  48.     public List<Link> findAllLinks() {
  49.         return linkMapper.findAll();
  50.     }
  52.     @Override
  53.     @Cacheable(value = LINKS_CACHE_NAME, key = "'links_id_'+#linkId", unless = "#result == null")
  54.     public Link findByLinkId(Long linkId) {
  55.         return linkMapper.selectById(linkId);
  56.     }
  58.     @Override
  59.     @Cacheable(value = LINKS_CACHE_NAME, key = "'links_count'")
  60.     public Integer getCount() {
  61.         return linkMapper.selectCount(null);
  62.     }
  63. }

除了 @Cacheable、@CacheEvict之外，还有@CachePut，一般不用

查询一律用 @Cacheable，先从 Redis 查有没有这个 key，如果没有则执行方法里的代码，从数据库查询，并将结果存到 Redis 中。

@CacheEvict 可以指定删除某个 key，也可以删除 value 集合的所有 key。


三、Redis工具类

  1. package com.liuyanzhao.sens.utils;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.data.redis.core.StringRedisTemplate;
  5. import org.springframework.stereotype.Component;
  7. import java.util.Map;
  8. import java.util.Set;
  9. import java.util.concurrent.TimeUnit;
  11. /**
  12.  * @author 言曌
  13.  * @date 2018/12/16 下午6:57
  14.  */
  15. @Component
  16. public class RedisUtil {
  18.     @Autowired
  19.     private StringRedisTemplate redisTemplate;
  22.     // Key（键），简单的key-value操作
  23.     /**
  24.      * 实现命令：TTL key，以秒为单位，返回给定 key的剩余生存时间(TTL, time to live)。
  25.      *
  26.      * @param key
  27.      * @return
  28.      */
  29.     public long ttl(String key) {
  30.         return redisTemplate.getExpire(key);
  31.     }
  32.     /**
  33.      * 实现命令：expire 设置过期时间，单位秒
  34.      *
  35.      * @param key
  36.      * @return
  37.      */
  38.     public void expire(String key, long timeout) {
  39.         redisTemplate.expire(key, timeout, TimeUnit.SECONDS);
  40.     }
  41.     /**
  42.      * 实现命令：INCR key，增加key一次
  43.      *
  44.      * @param key
  45.      * @return
  46.      */
  47.     public long incr(String key, long delta) {
  48.         return redisTemplate.opsForValue().increment(key, delta);
  49.     }
  52.     /**
  53.      * 实现命令： key，减少key一次
  54.      *
  55.      * @param key
  56.      * @return
  57.      */
  58.     public long decr(String key, long delta) {
  59.         if(delta<0){
  60. //            throw new RuntimeException("递减因子必须大于0");
  61.             del(key);
  62.             return 0;
  63.         }
  64.         return redisTemplate.opsForValue().increment(key, -delta);
  65.     }
  66.     /**
  67.      * 实现命令：KEYS pattern，查找所有符合给定模式 pattern的 key
  68.      */
  69.     public Set<String> keys(String pattern) {
  70.         return redisTemplate.keys(pattern);
  71.     }
  72.     /**
  73.      * 实现命令：DEL key，删除一个key
  74.      *
  75.      * @param key
  76.      */
  77.     public void del(String key) {
  78.         redisTemplate.delete(key);
  79.     }
  80.     // String（字符串）
  81.     /**
  82.      * 实现命令：SET key value，设置一个key-value（将字符串值 value关联到 key）
  83.      *
  84.      * @param key
  85.      * @param value
  86.      */
  87.     public void set(String key, String value) {
  88.         redisTemplate.opsForValue().set(key, value);
  89.     }
  90.     /**
  91.      * 实现命令：SET key value EX seconds，设置key-value和超时时间（秒）
  92.      *
  93.      * @param key
  94.      * @param value
  95.      * @param timeout （以秒为单位）
  96.      */
  97.     public void set(String key, String value, long timeout) {
  98.         redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
  99.     }
  100.     /**
  101.      * 实现命令：GET key，返回 key所关联的字符串值。
  102.      *
  103.      * @param key
  104.      * @return value
  105.      */
  106.     public String get(String key) {
  107.         return (String) redisTemplate.opsForValue().get(key);
  108.     }
  109.     // Hash（哈希表）
  110.     /**
  111.      * 实现命令：HSET key field value，将哈希表 key中的域 field的值设为 value
  112.      *
  113.      * @param key
  114.      * @param field
  115.      * @param value
  116.      */
  117.     public void hset(String key, String field, Object value) {
  118.         redisTemplate.opsForHash().put(key, field, value);
  119.     }
  120.     /**
  121.      * 实现命令：HGET key field，返回哈希表 key中给定域 field的值
  122.      *
  123.      * @param key
  124.      * @param field
  125.      * @return
  126.      */
  127.     public String hget(String key, String field) {
  128.         return (String) redisTemplate.opsForHash().get(key, field);
  129.     }
  130.     /**
  131.      * 实现命令：HDEL key field [field ...]，删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。
  132.      *
  133.      * @param key
  134.      * @param fields
  135.      */
  136.     public void hdel(String key, Object... fields) {
  137.         redisTemplate.opsForHash().delete(key, fields);
  138.     }
  139.     /**
  140.      * 实现命令：HGETALL key，返回哈希表 key中，所有的域和值。
  141.      *
  142.      * @param key
  143.      * @return
  144.      */
  145.     public Map<Object, Object> hgetall(String key) {
  146.         return redisTemplate.opsForHash().entries(key);
  147.     }
  148.     // List（列表）
  149.     /**
  150.      * 实现命令：LPUSH key value，将一个值 value插入到列表 key的表头
  151.      *
  152.      * @param key
  153.      * @param value
  154.      * @return 执行 LPUSH命令后，列表的长度。
  155.      */
  156.     public long lpush(String key, String value) {
  157.         return redisTemplate.opsForList().leftPush(key, value);
  158.     }
  159.     /**
  160.      * 实现命令：LPOP key，移除并返回列表 key的头元素。
  161.      *
  162.      * @param key
  163.      * @return 列表key的头元素。
  164.      */
  165.     public String lpop(String key) {
  166.         return (String) redisTemplate.opsForList().leftPop(key);
  167.     }
  168.     /**
  169.      * 实现命令：RPUSH key value，将一个值 value插入到列表 key的表尾(最右边)。
  170.      *
  171.      * @param key
  172.      * @param value
  173.      * @return 执行 LPUSH命令后，列表的长度。
  174.      */
  175.     public long rpush(String key, String value) {
  176.         return redisTemplate.opsForList().rightPush(key, value);
  177.     }
  178. }

使用的时候只需要注入 RedisUtil，然后就可以简单操作 Redis



最终效果









历史上的今天
一月
18日
  • 微信
  • 交流学习，资料分享
  • weinxin
  • 个人淘宝
  • 店铺名：言曌博客咨询部

  • (部分商品未及时上架淘宝)
avatar

发表评论

avatar 登录者：匿名
匿名评论，评论回复后会有邮件通知

  

已通过评论：0   待审核评论数：0