首页 > Spring Boot 整合Redis 实现缓存

Spring Boot 整合Redis 实现缓存

 

本文提纲
一、缓存的应用场景
二、更新缓存的策略
三、运行 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 获取。减少了去数据库查询的次数。但会出现新的问题，就是如何对缓存进行更新？这就是下面要讲的。

二、更新缓存的策略

参考《缓存更新的套路》http://coolshell.cn/articles/17416.html，缓存更新的模式有四种：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
2
3
4
5
6
7
8
DROP TABLE IF EXISTS  `city`;
CREATE TABLE `city` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '城市编号',
  `province_id` int(10) unsigned  NOT NULL COMMENT '省份编号',
  `city_name` varchar(25) DEFAULT NULL COMMENT '城市名称',
  `description` varchar(25) DEFAULT NULL COMMENT '描述',
  PRIMARY KEY (`id`)
) 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
2
3
4
5
6
7
springboot-mybatis-redis 工程项目结构如下图所示：
org.spring.springboot.controller - Controller 层
org.spring.springboot.dao - 数据操作层 DAO
org.spring.springboot.domain - 实体类
org.spring.springboot.service - 业务逻辑层
Application - 应用启动类
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
2
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='水好,天蓝'}
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
2017-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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
"1.0" encoding="UTF-8"?>
"http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    4.0.0</modelVersion>
    springboot</groupId>
    springboot-mybatis-redis</artifactId>
    0.0.1-SNAPSHOT</version>
    springboot-mybatis-redis :: 整合 Mybatis 并使用 Redis 作为缓存</name>
    
    
        org.springframework.boot</groupId>
        spring-boot-starter-parent</artifactId>
        1.5.1.RELEASE</version>
    </parent>
    
        1.2.0</mybatis-spring-boot>
        5.1.39</mysql-connector>
        1.3.2.RELEASE</spring-boot-starter-redis-version>
    </properties>
    
        
        
            org.springframework.boot</groupId>
            spring-boot-starter-redis</artifactId>
            ${spring-boot-starter-redis-version}</version>
        </dependency>
        
        
            org.springframework.boot</groupId>
            spring-boot-starter-web</artifactId>
        </dependency>
        
        
            org.springframework.boot</groupId>
            spring-boot-starter-test</artifactId>
            test</scope>
        </dependency>
        
        
            org.mybatis.spring.boot</groupId>
            mybatis-spring-boot-starter</artifactId>
            ${mybatis-spring-boot}</version>
        </dependency>
        
        
            mysql</groupId>
            mysql-connector-java</artifactId>
            ${mysql-connector}</version>
        </dependency>
        
        
            junit</groupId>
            junit</artifactId>
            4.12</version>
        </dependency>
    </dependencies>
</project>
包括了 Spring Boot Reids 依赖、 MySQL 依赖和 Mybatis 依赖。
在 application.properties 应用配置文件，增加 Redis 相关配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
## 数据源配置
spring.datasource.url=jdbc:mysql://localhost:3306/springbootdb?useUnicode=true&characterEncoding=utf8
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
## Mybatis 配置
mybatis.typeAliasesPackage=org.spring.springboot.domain
mybatis.mapperLocations=classpath:mapper/*.xml
## Redis 配置
## Redis数据库索引（默认为0）
spring.redis.database=0
## Redis服务器地址
spring.redis.host=127.0.0.1
## Redis服务器连接端口
spring.redis.port=6379
## Redis服务器连接密码（默认为空）
spring.redis.password=
## 连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=8
## 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
## 连接池中的最大空闲连接
spring.redis.pool.max-idle=8
## 连接池中的最小空闲连接
spring.redis.pool.min-idle=0
## 连接超时时间（毫秒）
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
2
Serializable
java.lang.IllegalArgumentException: DefaultSerializer requires a Serializable payload but received an object of type
City.java 城市对象：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
package org.spring.springboot.domain;
import java.io.Serializable;
/**
 * 城市实体类
 *
 * Created by bysocket on 07/02/2017.
 */
public class City implements Serializable {
    private static final long serialVersionUID = -1L;
    /**
     * 城市编号
     */
    private Long id;
    /**
     * 省份编号
     */
    private Long provinceId;
    /**
     * 城市名称
     */
    private String cityName;
    /**
     * 描述
     */
    private String description;
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public Long getProvinceId() {
        return provinceId;
    }
    public void setProvinceId(Long provinceId) {
        this.provinceId = provinceId;
    }
    public String getCityName() {
        return cityName;
    }
    public void setCityName(String cityName) {
        this.cityName = cityName;
    }
    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
    @Override
    public String toString() {
        return "City{" +
                "id=" + id +
                ", provinceId=" + provinceId +
                ", cityName='" + cityName + ''' +
                ", description='" + description + ''' +
                '}';
    }
}
如果需要自定义序列化实现，只要实现 RedisSerializer 接口去实现即可，然后在使用 RedisTemplate.setValueSerializer 方法去设置你实现的序列化实现。
主要还是城市业务逻辑实现类 CityServiceImpl.java：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
package org.spring.springboot.service.impl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.spring.springboot.dao.CityDao;
import org.spring.springboot.domain.City;
import org.spring.springboot.service.CityService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.concurrent.TimeUnit;
/**
 * 城市业务逻辑实现类
 *

 * Created by bysocket on 07/02/2017.
 */
@Service
public class CityServiceImpl implements CityService {
    private static final Logger LOGGER = LoggerFactory.getLogger(CityServiceImpl.class);
    @Autowired
    private CityDao cityDao;
    @Autowired
    private RedisTemplate redisTemplate;
    /**
     * 获取城市逻辑：
     * 如果缓存存在，从缓存中获取城市信息
     * 如果缓存不存在，从 DB 中获取城市信息，然后插入缓存
     */
    public City findCityById(Long id) {
        // 从缓存中获取城市信息
        String key = "city_" + id;
        ValueOperations operations = redisTemplate.opsForValue();
        // 缓存存在
        boolean hasKey = redisTemplate.hasKey(key);
        if (hasKey) {
            City city = operations.get(key);
            LOGGER.info("CityServiceImpl.findCityById() : 从缓存中获取了城市 >> " + city.toString());
            return city;
        }
        // 从 DB 中获取城市信息
        City city = cityDao.findById(id);
        // 插入缓存
        operations.set(key, city, 10, TimeUnit.SECONDS);
        LOGGER.info("CityServiceImpl.findCityById() : 城市插入缓存 >> " + city.toString());
        return city;
    }
    @Override
    public Long saveCity(City city) {
        return cityDao.saveCity(city);
    }
    /**
     * 更新城市逻辑：
     * 如果缓存存在，删除
     * 如果缓存不存在，不操作
     */
    @Override
    public Long updateCity(City city) {
        Long ret = cityDao.updateCity(city);
        // 缓存存在，删除缓存
        String key = "city_" + city.getId();
        boolean hasKey = redisTemplate.hasKey(key);
        if (hasKey) {
            redisTemplate.delete(key);
            LOGGER.info("CityServiceImpl.updateCity() : 从缓存中删除城市 >> " + city.toString());
        }
        return ret;
    }
    @Override
    public Long deleteCity(Long id) {
        Long ret = cityDao.deleteCity(id);
        // 缓存存在，删除缓存
        String key = "city_" + id;
        boolean hasKey = redisTemplate.hasKey(key);
        if (hasKey) {
            redisTemplate.delete(key);
            LOGGER.info("CityServiceImpl.deleteCity() : 从缓存中删除城市 ID >> " + id);
        }
        return ret;
    }
}
首先这里注入了 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 缓存时，一个是缓存对象需要序列化，二个是缓存更新策略是如何的。

转载于:https://www.cnblogs.com/Soy-technology/p/11025089.html

更多相关：

  • ehchache验证缓存过期的api_ASP.NET Core ResponseCache进行缓存操作

    (给DotNet加星标，提升.Net技能)转自：HueiFengcnblogs.com/yyfh/p/12361255.html前言本章将介绍客户端缓存将介绍浏览器缓存和服务端缓存，使用浏览器缓存将减少对web服务器的请求次数，同时可以提升性能，避免重复的运算浪费。ASP.NET Core对于HTTP缓存分为两种：客户端(浏览器缓...

  • ATS 6.2.1中缓存文件过期并不回源校验的“坑”

    事先说明 标题说是“坑”，并没有说是“bug”，也就是多半是玩的姿势不对。 线上问题 我司(lecloud)目前线上大小文件都是使用的ATS 6.2.1版本，昨天运维反馈有文件超过缓存时间并不回源刷新，截图如下： 现象就是：age超过max-age了，过期了不更新！ 另外需要说的一点就是，源站是可以正常回源的。 复...

  • ATS缓存相关话题

    将追加的主题 内存常驻副本(resident alternates)缓存对象刷新(object refresh) 缓存一致性(Cache Consistency) ATS缓存是完全一致性的，除非你不小心踢掉电源，让ATS突然关机。如果要禁用硬盘驱动器自身的缓存，你需要使用下面的命令 hdparm -W0 缓存系统会校验可用...

  • ATS名词术语(待续)

    ATS名词术语 副本(alternate) 缓存对象(cache object)的一种变体，最初创建该术语是为了处理HTTP协议中的VARY机制(RFC2616#sec14.44)，现在多用于其它的目的。一个对象的所有副本必须以某种方式等价，也就是说，它们是同一个流的等价形式，最常用的一个例子就是，一个流既有普通版本也有压缩版本。...

  • ATS 5.3.0中parent.config配置文件解读

    该博文翻译自参考文献[1] parent.config parent.config文件识别用在缓存分级中的父代理，用这个文件去执行下面的配置： 搭建父分级缓存，兼容多父级缓存和父级缓存故障转移配置指定的URL请求避开父代理缓存 仅当父缓存选项开启后，ATS才能使用parent.config文件。 当你修改parent.conf...

  • 世界10大科技城市

        未来的科技产品会在什么地方出现？据美国媒体3月13日评出的“世界十大科技城市排行榜”，以下的10个城市正让我们的梦想成为现实。

  • python 视频播放 拖动_视频画中画效果，拖动进度条可以seek到相应视频帧显示

    在视频开发中，我们常常看到这样的效果，拖动进度条时，或是在进度条上方或是在屏幕中间，显示拖动进度条位置时刻的某一帧画面。这个需求，如果是你，你会如何做？通常一个需求，不仅要考虑实现，还有考虑一些是否有性能上影响。下面我想到的4个方案：1、在拖动过程中，可以通过TextureView来显示预览图，拖动进度条到某个position后，通过...

  • Android studio 获取每次编译apk时的日期

    项目中需要获取apk的编译日期，首先肯定是用手动的方式获取，但这样容易遗忘，怎么样通过代码的方式获取呢？ 其实android 为我们提供了一个BuildConfig的类，android 每次编译的时候都会自动生成 一次BuildConfig 类，这个类包含着编译时的各个参数，所以只需要在这个类中增加一个常量，然后设定这个常量的值就是编...

  • Moss/Sharepoint 一些很重要的API备忘

    1.根据用户名获取用户 SPUser user = web.EnsureUser((new SPFieldLookupValue(item["Mitarbeiter"].ToString())).LookupValue);   2.根据guid获取Feature对象 SPFeature listDisplaySettingFeatu...

  • 获取access中表的相关信息

    就用到两条.net自带的获取数据库信息的语句 OleDbConnection con = new OleDbConnection(connection); // OleDB数据库连接实例   // 获取数据库中表的相关信息DataTable dt = con.GetOleDbSchemaTable(OleDbSchemaGuid.Ta...

  • scrollLeft,scrollWidth,clientWidth,offsetWidth到底指的哪到哪的距离

    轉自:http://www.cnblogs.com/mrhgw/archive/2006/11/08/553737.html   补充： scrollHeight: 获取对象的滚动高度。 scrollLeft:设置或获取位于对象左边界和窗口中目前可见内容的最左端之间的距离 scrollTop:设置或获取位于对象最顶端和窗口中可见...

©2024 11GX.COM