Spring Boot 整合 Redis 实现缓存操作

  1. 云栖社区>
  2. 博客>
  3. 正文

Spring Boot 整合 Redis 实现缓存操作

行者武松 2017-08-01 14:36:00 浏览1708
展开阅读全文


一、缓存的应用场景

二、更新缓存的策略

三、运行 springboot-mybatis-redis 工程案例

四、springboot-mybatis-redis 工程代码配置详解

运行环境:

Mac OS 10.12.x

JDK 8 +

Redis 3.2.8

Spring Boot 1.5.1.RELEASE

一、缓存的应用场景

什么是缓存?

在互联网场景下,尤其2C端大流量场景下,需要将一些经常展现和不会频繁变更的数据,存放在存取速率更快的地方。缓存就是一个存储器,在技术选型中,常用 Redis 作为缓存数据库。缓存主要是在获取资源方便性能优化的关键方面。

Redis 是一个高性能的 key-value 数据库。GitHub 地址:https://github.com/antirez/redis 。Github 是这么描述的:

Redis is an in-memory database that persists on disk. The data model is key-value, but many different kind of values are supported: Strings, Lists, Sets, Sorted Sets, Hashes, HyperLogLogs, Bitmaps.

缓存的应用场景有哪些呢?

比如常见的电商场景,根据商品 ID 获取商品信息时,店铺信息和商品详情信息就可以缓存在 Redis,直接从 Redis 获取。减少了去数据库查询的次数。但会出现新的问题,就是如何对缓存进行更新?这就是下面要讲的。

二、更新缓存的策略

缓存更新的模式有四种:Cache aside, Read through, Write through, Write behind caching。

这里我们使用的是 Cache Aside 策略,从三个维度:(摘自 耗子叔叔博客)

失效:应用程序先从cache取数据,没有得到,则从数据库中取数据,成功后,放到缓存中。

命中:应用程序从cache中取数据,取到后返回。

更新:先把数据存到数据库中,成功后,再让缓存失效。

大致流程如下:

获取商品详情举例

a. 从商品 Cache 中获取商品详情,如果存在,则返回获取 Cache 数据返回。

b. 如果不存在,则从商品 DB 中获取。获取成功后,将数据存到 Cache 中。则下次获取商品详情,就可以从 Cache 就可以得到商品详情数据。

c. 从商品 DB 中更新或者删除商品详情成功后,则从缓存中删除对应商品的详情缓存

三、运行 springboot-mybatis-redis 工程案例

git clone 下载工程 springboot-learning-example ,项目地址见 GitHub – https://github.com/JeffLi1993/springboot-learning-example

下面开始运行工程步骤(Quick Start):

1.数据库和 Redis 准备

a.创建数据库 springbootdb:


  1. CREATE DATABASE springbootdb 

b.创建表 city :(因为我喜欢徒步)


  1. DROP TABLE IF EXISTS  `city`; 
  2. CREATE TABLE `city` ( 
  3.   `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '城市编号'
  4.   `province_id` int(10) unsigned  NOT NULL COMMENT '省份编号'
  5.   `city_name` varchar(25) DEFAULT NULL COMMENT '城市名称'
  6.   `description` varchar(25) DEFAULT NULL COMMENT '描述'
  7.   PRIMARY KEY (`id`) 
  8. ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8; 

c.插入数据


  1. INSERT city VALUES (1 ,1,'温岭市','BYSocket 的家在温岭。'); 

d.本地安装 Redis

详见写过的文章《 Redis 安装 》http://www.bysocket.com/?p=917

2. springboot-mybatis-redis 工程项目结构介绍


  1. springboot-mybatis-redis 工程项目结构如下图所示: 
  2. org.spring.springboot.controller - Controller 层 
  3. org.spring.springboot.dao - 数据操作层 DAO 
  4. org.spring.springboot.domain - 实体类 
  5. org.spring.springboot.service - 业务逻辑层 
  6. Application - 应用启动类 
  7. application.properties - 应用配置文件,应用启动会自动读取配置 

3.改数据库配置

打开 application.properties 文件, 修改相应的数据源配置,比如数据源地址、账号、密码等。

(如果不是用 MySQL,自行添加连接驱动 pom,然后修改驱动名配置。)

4.编译工程

在项目根目录 springboot-learning-example,运行 maven 指令:


  1. mvn clean install 

5.运行工程

右键运行 springboot-mybatis-redis 工程 Application 应用启动类的 main 函数。

项目运行成功后,这是个 HTTP OVER JSON 服务项目。所以用 postman 工具可以如下操作

根据 ID,获取城市信息

GET http://127.0.0.1:8080/api/city/1

再请求一次,获取城市信息会发现数据获取的耗时快了很多。服务端 Console 输出的日志:


  1. 2017-04-13 18:29:00.273  INFO 13038 --- [nio-8080-exec-1] o.s.s.service.impl.CityServiceImpl       : CityServiceImpl.findCityById() : 城市插入缓存 >> City{id=12, provinceId=3, cityName='三亚', description='水好,天蓝'} 
  2. 2017-04-13 18:29:03.145  INFO 13038 --- [nio-8080-exec-2] o.s.s.service.impl.CityServiceImpl       : CityServiceImpl.findCityById() : 从缓存中获取了城市 >> City{id=12, provinceId=3, cityName='三亚', description='水好,天蓝'} 

可见,第一次是从数据库 DB 获取数据,并插入缓存,第二次直接从缓存中取。

更新城市信息

PUT http://127.0.0.1:8080/api/city

删除城市信息

DELETE http://127.0.0.1:8080/api/city/2

这两种操作中,如果缓存有对应的数据,则删除缓存。服务端 Console 输出的日志:


  1. 12017-04-13 18:29:52.248 INFO 13038 --- [nio-8080-exec-9] o.s.s.service.impl.CityServiceImpl : CityServiceImpl.deleteCity() : 从缓存中删除城市 ID >> 12 

四、springboot-mybatis-redis 工程代码配置详解

这里,我强烈推荐 注解 的方式实现对象的缓存。但是这里为了更好说明缓存更新策略。下面讲讲工程代码的实现。

pom.xml 依赖配置:


  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> 
  5.   
  6.     <groupId>springboot</groupId> 
  7.     <artifactId>springboot-mybatis-redis</artifactId> 
  8.     <version>0.0.1-SNAPSHOT</version> 
  9.     <name>springboot-mybatis-redis :: 整合 Mybatis 并使用 Redis 作为缓存</name
  10.   
  11.     <!-- Spring Boot 启动父依赖 --> 
  12.     <parent> 
  13.         <groupId>org.springframework.boot</groupId> 
  14.         <artifactId>spring-boot-starter-parent</artifactId> 
  15.         <version>1.5.1.RELEASE</version> 
  16.     </parent> 
  17.   
  18.     <properties> 
  19.         <mybatis-spring-boot>1.2.0</mybatis-spring-boot> 
  20.         <mysql-connector>5.1.39</mysql-connector> 
  21.         <spring-boot-starter-redis-version>1.3.2.RELEASE</spring-boot-starter-redis-version> 
  22.     </properties> 
  23.   
  24.     <dependencies> 
  25.   
  26.         <!-- Spring Boot Reids 依赖 --> 
  27.         <dependency> 
  28.             <groupId>org.springframework.boot</groupId> 
  29.             <artifactId>spring-boot-starter-redis</artifactId> 
  30.             <version>${spring-boot-starter-redis-version}</version> 
  31.         </dependency> 
  32.   
  33.         <!-- Spring Boot Web 依赖 --> 
  34.         <dependency> 
  35.             <groupId>org.springframework.boot</groupId> 
  36.             <artifactId>spring-boot-starter-web</artifactId> 
  37.         </dependency> 
  38.   
  39.         <!-- Spring Boot Test 依赖 --> 
  40.         <dependency> 
  41.             <groupId>org.springframework.boot</groupId> 
  42.             <artifactId>spring-boot-starter-test</artifactId> 
  43.             <scope>test</scope> 
  44.         </dependency> 
  45.   
  46.         <!-- Spring Boot Mybatis 依赖 --> 
  47.         <dependency> 
  48.             <groupId>org.mybatis.spring.boot</groupId> 
  49.             <artifactId>mybatis-spring-boot-starter</artifactId> 
  50.             <version>${mybatis-spring-boot}</version> 
  51.         </dependency> 
  52.   
  53.         <!-- MySQL 连接驱动依赖 --> 
  54.         <dependency> 
  55.             <groupId>mysql</groupId> 
  56.             <artifactId>mysql-connector-java</artifactId> 
  57.             <version>${mysql-connector}</version> 
  58.         </dependency> 
  59.   
  60.         <!-- Junit --> 
  61.         <dependency> 
  62.             <groupId>junit</groupId> 
  63.             <artifactId>junit</artifactId> 
  64.             <version>4.12</version> 
  65.         </dependency> 
  66.     </dependencies> 
  67. </project> 

包括了 Spring Boot Reids 依赖、 MySQL 依赖和 Mybatis 依赖。

在 application.properties 应用配置文件,增加 Redis 相关配置


  1. ## 数据源配置 
  2. spring.datasource.url=jdbc:mysql://localhost:3306/springbootdb?useUnicode=true&characterEncoding=utf8 
  3. spring.datasource.username=root 
  4. spring.datasource.password=123456 
  5. spring.datasource.driver-class-name=com.mysql.jdbc.Driver 
  6.   
  7. ## Mybatis 配置 
  8. mybatis.typeAliasesPackage=org.spring.springboot.domain 
  9. mybatis.mapperLocations=classpath:mapper/*.xml 
  10.   
  11. ## Redis 配置 
  12. ## Redis数据库索引(默认为0) 
  13. spring.redis.database=0 
  14. ## Redis服务器地址 
  15. spring.redis.host=127.0.0.1 
  16. ## Redis服务器连接端口 
  17. spring.redis.port=6379 
  18. ## Redis服务器连接密码(默认为空) 
  19. spring.redis.password
  20. ## 连接池最大连接数(使用负值表示没有限制) 
  21. spring.redis.pool.max-active=8 
  22. ## 连接池最大阻塞等待时间(使用负值表示没有限制) 
  23. spring.redis.pool.max-wait=-1 
  24. ## 连接池中的最大空闲连接 
  25. spring.redis.pool.max-idle=8 
  26. ## 连接池中的最小空闲连接 
  27. spring.redis.pool.min-idle=0 
  28. ## 连接超时时间(毫秒) 
  29. spring.redis.timeout=0 

详细解释可以参考注释。对应的配置类:org.springframework.boot.autoconfigure.data.redis.RedisProperties

CityRestController 控制层依旧是 Restful 风格的,详情可以参考《Springboot 实现 Restful 服务,基于 HTTP / JSON 传输》。 http://www.bysocket.com/?p=1627 domain 对象 City 必须实现序列化,因为需要将对象序列化后存储到 Redis。如果没实现 Serializable ,控制台会爆出以下异常:


  1. Serializable 
  2. java.lang.IllegalArgumentException: DefaultSerializer requires a Serializable payload but received an object of type 

City.java 城市对象:


  1. package org.spring.springboot.domain; 
  2.   
  3. import java.io.Serializable
  4.   
  5. /** 
  6.  * 城市实体类 
  7.  * 
  8.  * Created by bysocket on 07/02/2017. 
  9.  */ 
  10. public class City implements Serializable { 
  11.   
  12.     private static final long serialVersionUID = -1L; 
  13.   
  14.     /** 
  15.      * 城市编号 
  16.      */ 
  17.     private Long id; 
  18.   
  19.     /** 
  20.      * 省份编号 
  21.      */ 
  22.     private Long provinceId; 
  23.   
  24.     /** 
  25.      * 城市名称 
  26.      */ 
  27.     private String cityName; 
  28.   
  29.     /** 
  30.      * 描述 
  31.      */ 
  32.     private String description; 
  33.   
  34.     public Long getId() { 
  35.         return id; 
  36.     } 
  37.   
  38.     public void setId(Long id) { 
  39.         this.id = id; 
  40.     } 
  41.   
  42.     public Long getProvinceId() { 
  43.         return provinceId; 
  44.     } 
  45.   
  46.     public void setProvinceId(Long provinceId) { 
  47.         this.provinceId = provinceId; 
  48.     } 
  49.   
  50.     public String getCityName() { 
  51.         return cityName; 
  52.     } 
  53.   
  54.     public void setCityName(String cityName) { 
  55.         this.cityName = cityName; 
  56.     } 
  57.   
  58.     public String getDescription() { 
  59.         return description; 
  60.     } 
  61.   
  62.     public void setDescription(String description) { 
  63.         this.description = description; 
  64.     } 
  65.   
  66.     @Override 
  67.     public String toString() { 
  68.         return "City{" + 
  69.                 "id=" + id + 
  70.                 ", provinceId=" + provinceId + 
  71.                 ", cityName='" + cityName + '\'' + 
  72.                 ", description='" + description + '\'' + 
  73.                 '}'
  74.     } 

如果需要自定义序列化实现,只要实现 RedisSerializer 接口去实现即可,然后在使用 RedisTemplate.setValueSerializer 方法去设置你实现的序列化实现。

主要还是城市业务逻辑实现类 CityServiceImpl.java:


  1. package org.spring.springboot.service.impl; 
  2.   
  3. import org.slf4j.Logger; 
  4. import org.slf4j.LoggerFactory; 
  5. import org.spring.springboot.dao.CityDao; 
  6. import org.spring.springboot.domain.City; 
  7. import org.spring.springboot.service.CityService; 
  8. import org.springframework.beans.factory.annotation.Autowired; 
  9. import org.springframework.data.redis.core.RedisTemplate; 
  10. import org.springframework.data.redis.core.StringRedisTemplate; 
  11. import org.springframework.data.redis.core.ValueOperations; 
  12. import org.springframework.stereotype.Service; 
  13.   
  14. import java.util.List; 
  15. import java.util.concurrent.TimeUnit; 
  16.   
  17. /** 
  18.  * 城市业务逻辑实现类 
  19.  * <p> 
  20.  * Created by bysocket on 07/02/2017. 
  21.  */ 
  22. @Service 
  23. public class CityServiceImpl implements CityService { 
  24.   
  25.     private static final Logger LOGGER = LoggerFactory.getLogger(CityServiceImpl.class); 
  26.   
  27.     @Autowired 
  28.     private CityDao cityDao; 
  29.   
  30.     @Autowired 
  31.     private RedisTemplate redisTemplate; 
  32.   
  33.     /** 
  34.      * 获取城市逻辑: 
  35.      * 如果缓存存在,从缓存中获取城市信息 
  36.      * 如果缓存不存在,从 DB 中获取城市信息,然后插入缓存 
  37.      */ 
  38.     public City findCityById(Long id) { 
  39.         // 从缓存中获取城市信息 
  40.         String key = "city_" + id; 
  41.         ValueOperations<String, City> operations = redisTemplate.opsForValue(); 
  42.   
  43.         // 缓存存在 
  44.         boolean hasKey = redisTemplate.hasKey(key); 
  45.         if (hasKey) { 
  46.             City city = operations.get(key); 
  47.   
  48.             LOGGER.info("CityServiceImpl.findCityById() : 从缓存中获取了城市 >> " + city.toString()); 
  49.             return city; 
  50.         } 
  51.   
  52.         // 从 DB 中获取城市信息 
  53.         City city = cityDao.findById(id); 
  54.   
  55.         // 插入缓存 
  56.         operations.set(key, city, 10, TimeUnit.SECONDS); 
  57.         LOGGER.info("CityServiceImpl.findCityById() : 城市插入缓存 >> " + city.toString()); 
  58.   
  59.         return city; 
  60.     } 
  61.   
  62.     @Override 
  63.     public Long saveCity(City city) { 
  64.         return cityDao.saveCity(city); 
  65.     } 
  66.   
  67.     /** 
  68.      * 更新城市逻辑: 
  69.      * 如果缓存存在,删除 
  70.      * 如果缓存不存在,不操作 
  71.      */ 
  72.     @Override 
  73.     public Long updateCity(City city) { 
  74.         Long ret = cityDao.updateCity(city); 
  75.   
  76.         // 缓存存在,删除缓存 
  77.         String key = "city_" + city.getId(); 
  78.         boolean hasKey = redisTemplate.hasKey(key); 
  79.         if (hasKey) { 
  80.             redisTemplate.delete(key); 
  81.   
  82.             LOGGER.info("CityServiceImpl.updateCity() : 从缓存中删除城市 >> " + city.toString()); 
  83.         } 
  84.   
  85.         return ret; 
  86.     } 
  87.   
  88.     @Override 
  89.     public Long deleteCity(Long id) { 
  90.   
  91.         Long ret = cityDao.deleteCity(id); 
  92.   
  93.         // 缓存存在,删除缓存 
  94.         String key = "city_" + id; 
  95.         boolean hasKey = redisTemplate.hasKey(key); 
  96.         if (hasKey) { 
  97.             redisTemplate.delete(key); 
  98.   
  99.             LOGGER.info("CityServiceImpl.deleteCity() : 从缓存中删除城市 ID >> " + id); 
  100.         } 
  101.         return ret; 
  102.     } 
  103.   

首先这里注入了 RedisTemplate 对象。联想到 Spring 的 JdbcTemplate ,RedisTemplate 封装了 RedisConnection,具有连接管理,序列化和 Redis 操作等功能。还有针对 String 的支持对象 StringRedisTemplate。

Redis 操作视图接口类用的是 ValueOperations,对应的是 Redis String/Value 操作。还有其他的操作视图,ListOperations、SetOperations、ZSetOperations 和 HashOperations 。ValueOperations 插入缓存是可以设置失效时间,这里设置的失效时间是 10 s。

回到更新缓存的逻辑

a. findCityById 获取城市逻辑:

如果缓存存在,从缓存中获取城市信息

如果缓存不存在,从 DB 中获取城市信息,然后插入缓存

b. deleteCity 删除 / updateCity 更新城市逻辑:

如果缓存存在,删除

如果缓存不存在,不操作

其他不明白的,可以 git clone 下载工程 springboot-learning-example ,工程代码注解很详细。 https://github.com/JeffLi1993/springboot-learning-example。

五、小结

本文涉及到 Spring Boot 在使用 Redis 缓存时,一个是缓存对象需要序列化,二个是缓存更新策略是如何的。


作者:泥沙砖瓦浆木匠

来源:51CTO

网友评论

登录后评论
0/500
评论
行者武松
+ 关注