SpringBoot整合Redis实现缓存

avatar 2018年06月02日17:57:18 6 8145 views
博主分享免费Java教学视频，B站账号：Java刘哥 ，长期提供技术问题解决、项目定制：本站商品点此
redis是一个基于内存的高性能key-value数据库，具有极高的读写速度。本文介绍 SpringBoot 和 Redis 的整合，以及如何在项目中具体应用。


一、我的需求


1、实时快速获得动态数据

如图，下图中的通知数5和消息数8在每个页面都是有的，不可能每次都从 MySQL 数据库里查询一下吧（下拉的详细信息是点击事件后才ajax加载）。我们知道 MySQL 是从硬盘读取，Redis 是从内存读取，速度比较可想而知。

所以我们这里可以使用 Redis 数据库，第一次先把计数从 MySQL 查出来，然后放到 Redis 数据库里，下次直接从 Redis 数据库读取。张三给李四发一条消息，只需要给李四的 Redis 数据库里该 key 记录 + 1，李四读取了这条消息，只需要给李四的 Redis 数据库里该 key -1。









2、排行榜或推荐内容(每天变动一次或七天变一次)

比如我这里右边侧边栏有本周用户排行榜(按文章数排序)，推荐关键词排行榜(按文章关键词次数排序)，热门文章排行榜（按评论数点赞数访问数等加权排序）。MySQL查询到数据后，我们还有进行处理排序，时间比较长。如果我们第一次查询后，然后将现成的数据存到 Redis 数据库中，下次访问就很快了，无论用户如何刷新页面，加载都很快。

Redis 也可以设置缓存过期时间，比如用户排行榜设置1小时更新一次，推荐关键词只有增删改的时候才更新，热门文章2小时更新一次。




二、基本准备


1、本地安装了 Redis 数据库

Linux 或 Mac 可以参考这篇文章：点此



2、启动查看端口





3、下载可视化客户端 rdm

通常情况下，我们可以在命令行下查看 Redis 数据库，但是可视化工具能更真实地让我们看到数据的结构。






三、开始代码


注意：本文用的 Redis 数据结构都是 String 类型，没有用到 List 类型

本文使用的 SpringBoot 版本 1.5.9

如果你的是 2.0 版本，在 RedisConfig.java 需要修改一下序列化工具部分



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



2、封装 redisTemplate 工具类
  1. package com.liuyanzhao.forum.util;
  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/3/18 下午1:11
  14.  */
  16. @Component
  17. public class RedisOperator {
  19. //  @Autowired
  20. //    private RedisTemplate<String, Object> redisTemplate;
  22.     @Autowired
  23.     private StringRedisTemplate redisTemplate;
  26.     // Key（键），简单的key-value操作
  28.     /**
  29.      * 实现命令：TTL key，以秒为单位，返回给定 key的剩余生存时间(TTL, time to live)。
  30.      *
  31.      * @param key
  32.      * @return
  33.      */
  34.     public long ttl(String key) {
  35.         return redisTemplate.getExpire(key);
  36.     }
  38.     /**
  39.      * 实现命令：expire 设置过期时间，单位秒
  40.      *
  41.      * @param key
  42.      * @return
  43.      */
  44.     public void expire(String key, long timeout) {
  45.         redisTemplate.expire(key, timeout, TimeUnit.SECONDS);
  46.     }
  48.     /**
  49.      * 实现命令：INCR key，增加key一次
  50.      *
  51.      * @param key
  52.      * @return
  53.      */
  54.     public long incr(String key, long delta) {
  55.         return redisTemplate.opsForValue().increment(key, delta);
  56.     }
  59.     /**
  60.      * 实现命令： key，减少key一次
  61.      *
  62.      * @param key
  63.      * @return
  64.      */
  65.     public long decr(String key, long delta) {
  66.         if(delta<0){
  67. //            throw new RuntimeException("递减因子必须大于0");
  68.             del(key);
  69.             return 0;
  70.         }
  71.         return redisTemplate.opsForValue().increment(key, -delta);
  72.     }
  75.     /**
  76.      * 实现命令：KEYS pattern，查找所有符合给定模式 pattern的 key
  77.      */
  78.     public Set<String> keys(String pattern) {
  79.         return redisTemplate.keys(pattern);
  80.     }
  82.     /**
  83.      * 实现命令：DEL key，删除一个key
  84.      *
  85.      * @param key
  86.      */
  87.     public void del(String key) {
  88.         redisTemplate.delete(key);
  89.     }
  91.     // String（字符串）
  93.     /**
  94.      * 实现命令：SET key value，设置一个key-value（将字符串值 value关联到 key）
  95.      *
  96.      * @param key
  97.      * @param value
  98.      */
  99.     public void set(String key, String value) {
  100.         redisTemplate.opsForValue().set(key, value);
  101.     }
  103.     /**
  104.      * 实现命令：SET key value EX seconds，设置key-value和超时时间（秒）
  105.      *
  106.      * @param key
  107.      * @param value
  108.      * @param timeout （以秒为单位）
  109.      */
  110.     public void set(String key, String value, long timeout) {
  111.         redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
  112.     }
  114.     /**
  115.      * 实现命令：GET key，返回 key所关联的字符串值。
  116.      *
  117.      * @param key
  118.      * @return value
  119.      */
  120.     public String get(String key) {
  121.         return (String) redisTemplate.opsForValue().get(key);
  122.     }
  124.     // Hash（哈希表）
  126.     /**
  127.      * 实现命令：HSET key field value，将哈希表 key中的域 field的值设为 value
  128.      *
  129.      * @param key
  130.      * @param field
  131.      * @param value
  132.      */
  133.     public void hset(String key, String field, Object value) {
  134.         redisTemplate.opsForHash().put(key, field, value);
  135.     }
  137.     /**
  138.      * 实现命令：HGET key field，返回哈希表 key中给定域 field的值
  139.      *
  140.      * @param key
  141.      * @param field
  142.      * @return
  143.      */
  144.     public String hget(String key, String field) {
  145.         return (String) redisTemplate.opsForHash().get(key, field);
  146.     }
  148.     /**
  149.      * 实现命令：HDEL key field [field ...]，删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。
  150.      *
  151.      * @param key
  152.      * @param fields
  153.      */
  154.     public void hdel(String key, Object... fields) {
  155.         redisTemplate.opsForHash().delete(key, fields);
  156.     }
  158.     /**
  159.      * 实现命令：HGETALL key，返回哈希表 key中，所有的域和值。
  160.      *
  161.      * @param key
  162.      * @return
  163.      */
  164.     public Map<Object, Object> hgetall(String key) {
  165.         return redisTemplate.opsForHash().entries(key);
  166.     }
  168.     // List（列表）
  170.     /**
  171.      * 实现命令：LPUSH key value，将一个值 value插入到列表 key的表头
  172.      *
  173.      * @param key
  174.      * @param value
  175.      * @return 执行 LPUSH命令后，列表的长度。
  176.      */
  177.     public long lpush(String key, String value) {
  178.         return redisTemplate.opsForList().leftPush(key, value);
  179.     }
  181.     /**
  182.      * 实现命令：LPOP key，移除并返回列表 key的头元素。
  183.      *
  184.      * @param key
  185.      * @return 列表key的头元素。
  186.      */
  187.     public String lpop(String key) {
  188.         return (String) redisTemplate.opsForList().leftPop(key);
  189.     }
  191.     /**
  192.      * 实现命令：RPUSH key value，将一个值 value插入到列表 key的表尾(最右边)。
  193.      *
  194.      * @param key
  195.      * @param value
  196.      * @return 执行 LPUSH命令后，列表的长度。
  197.      */
  198.     public long rpush(String key, String value) {
  199.         return redisTemplate.opsForList().rightPush(key, value);
  200.     }
  202. }



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





4、RedisConfig.java
  1. package com.liuyanzhao.forum.config;
  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.cache.CacheManager;
  7. import org.springframework.cache.annotation.EnableCaching;
  8. import org.springframework.context.annotation.Bean;
  9. import org.springframework.context.annotation.Configuration;
  10. import org.springframework.data.redis.cache.RedisCacheManager;
  11. import org.springframework.data.redis.connection.RedisConnectionFactory;
  12. import org.springframework.data.redis.core.RedisTemplate;
  13. import org.springframework.data.redis.core.StringRedisTemplate;
  14. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  16. import java.util.HashMap;
  17. import java.util.Map;
  20. /**
  21.  * @author 言曌
  22.  * @date 2018/5/21 上午10:02
  23.  */
  24. @Configuration
  25. //@EnableRedisHttpSession(maxInactiveIntervalInSeconds = 3600 * 12)//最大过期时间
  26. @EnableCaching
  27. public class RedisConfig {
  29.     //缓存管理器
  30.     @Bean
  31.     public CacheManager cacheManager(@SuppressWarnings("rawtypes") RedisTemplate redisTemplate) {
  32.         RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
  33.         //设置缓存过期时间
  34.         Map<String, Long> expires = new HashMap<>();
  35.         expires.put("7d", 7 * 3600 * 24L);
  36.         expires.put("12h", 3600 * 12L);
  37.         expires.put("1h", 3600 * 1L);
  38.         expires.put("10m", 60 * 10L);
  39.         cacheManager.setExpires(expires);
  40.         cacheManager.setDefaultExpiration(7 * 3600 * 24);//默认缓存七天
  41.         return cacheManager;
  42.     }
  44.     @Bean
  45.     public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
  46.         StringRedisTemplate template = new StringRedisTemplate(factory);
  47.         setSerializer(template);//设置序列化工具
  48.         template.afterPropertiesSet();
  49.         return template;
  50.     }
  52.     private void setSerializer(StringRedisTemplate template) {
  53.         @SuppressWarnings({"rawtypes", "unchecked"})
  54.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
  55.         ObjectMapper om = new ObjectMapper();
  56.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  57.         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  58.         jackson2JsonRedisSerializer.setObjectMapper(om);
  59.         template.setValueSerializer(jackson2JsonRedisSerializer);
  60.     }
  61. }


四、简单的测试


新建一个控制器，测试一下之前封装的 RedisOperator
  1. package com.liuyanzhao.forum.controller;
  3. import com.alibaba.fastjson.JSON;
  4. import com.liuyanzhao.forum.entity.Article;
  5. import com.liuyanzhao.forum.entity.User;
  6. import com.liuyanzhao.forum.repository.ArticleRepository;
  7. import com.liuyanzhao.forum.util.RedisOperator;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.web.bind.annotation.RequestMapping;
  10. import org.springframework.web.bind.annotation.ResponseBody;
  11. import org.springframework.web.bind.annotation.RestController;
  13. import java.util.List;
  15. /**
  16.  * @author 言曌
  17.  * @date 2018/3/18 上午11:18
  18.  */
  20. @RestController
  21. @RequestMapping("/redis")
  22. public class RedisController {
  24.     @Autowired
  25.     private RedisOperator redis;
  27.     @Autowired
  28.     private ArticleRepository articleRepository;
  30.     @RequestMapping("/set")
  31.     @ResponseBody
  32.     public String set(){
  33.         redis.set("name","琪仔");
  34.         redis.incr("age",20);
  36.         User user = new User();
  37.         user.setId(234);
  38.         List<Article> articleList = articleRepository.findAll();
  39.         System.out.println(articleList);
  40.         redis.set("json:articleList", JSON.toJSONString(articleList));
  43.         return  "success";
  44.     }
  46.     @RequestMapping("/get")
  47.     @ResponseBody
  48.     public String get(){
  49.         return redis.get("json:articleList");
  50.     }
  53. }


五、具体应用到项目中


1、Sevice 中统计某个用户未阅读的消息数量，并添加到Redis
  1. @Override
  2.    @Cacheable(value = "12h", key = "'messageSize:'+#p0.id")
  3.    public Integer countNotReadMessageSize(User user) {
  4.        return messageRepository.countByUserAndStatus(user, MessageStatusEnum.NOT_READ_MESSAGE.getCode());
  5.    }





2、发布私信(好友的未读消息+1)
  1. @PostMapping("/messages")
  2. public ResponseEntity<Response> createMessage(Integer friendId, String content) {
  3. .......
  4.         //3、Redis 中 好友的未读消息+1
  5.         redisOperator.incr("messageSize:" + friendId, 1L);
  6. .....
  7. }



3、查看私信(自己的未读消息-N)
  1. @GetMapping("/manage/messages")
  2.    public ModelAndView messages( Integer uid) {
  3.           ......
  4.            // 查看好友发来的N消息，Redis中未读消息-N
  5.            redisOperator.decr("messageSize:" + user.getId(), notReadSize);
  6.           ......
  7.    }




六、@Cacheable、@CachePut、@CacheEvict 注解的使用

  1. @Transactional
  2.     @Override
  3.     //执行下面的方法，最终将结果添加(如果这个key存在，则覆盖)到Redis中
  4.     @CachePut(value = "7d", key = "'tags:'+#p0.id", unless = "#tag eq null")
  5.     public Tag saveTag(Tag tag) {
  6.         return tagRepository.save(tag);
  7.     }
  9.     @Override
  10.     //如果Redis数据库中没有这个key，执行下面方法，最终结果添加到Redis。如果key已存在，则直接从Redis获取，不执行下面方法
  11.     @Cacheable(value = "7d", key = "'tags:'+#id.toString()")
  12.     public Tag getTagById(Integer id) {
  13.         return tagRepository.findOne(id);
  14.     }
  16.     @Override
  17.     //condition为true执行@CacheEvict，将该key从Redis删除
  18.     @CacheEvict(value = "7d", key = "'tags:'+#id.toString()", condition = "#result eq true")
  19.     public Boolean removeTag(Integer id) {
  20.         tagRepository.delete(id);
  21.         return true;
  22.     }

注意：key 必须为String类型, @Cacheable中不能使用 #Result



除了上述使用方法参数作为key之外，Spring还为我们提供了一个root对象可以用来生成key。通过该root对象我们可以获取到以下信息。

参考这里：https://www.cnblogs.com/fashflying/p/6908028.html






































属性名称 描述 示例
methodName 当前方法名 #root.methodName
method 当前方法 #root.method.name
target 当前被调用的对象 #root.target
targetClass 当前被调用的对象的class #root.targetClass
args 当前方法参数组成的数组 #root.args[0]
caches 当前被调用的方法使用的Cache #root.caches[0].name


七、更多文章


Mac环境下安装配置Redis

Redis 命令大全


SpringBoot Redis 设置缓存过期时间












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

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

发表评论

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

  

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