SpringBoot(九) Redis 数据缓存

整合Redis非关系数据库作为内存缓存框架,并测试数据读取源。

简介

平时在项目中设计数据访问的时候往往都是采用直接访问数据库,采用数据库连接池来实现,但是如果我们的项目访问量过大或者访问过于频繁,将会对我们的数据库带来很大的压力。为了解决这个问题从而redis数据库脱颖而出,redis数据库出现时是以非关系数据库的光环展示在广大程序猿的面前的,后来redis的迭代版本支持了缓存数据、登录session状态(分布式session共享)等。所以又被作为内存缓存的形式应用到大型企业级项目中。

安装Redis

我们直接访问github网址:github.com/MSOpenTech/redis/releases ,下载最新的windows X64版本的压缩包,如下图所示:

第一个是安装程序方式可以直接安装不过不太喜欢那种形式,第二个则是压缩包的形式解压完就可以用,第三、四个都是源码文件。下载完成后随便解压到我们的盘符内的文件即可,如下图所示:

开启Redis

检查端口没有被占用,我们需要在cmd命令窗口执行运行Redis,我们首先使用cmd命令进入到Redis解压目录并且执行 redis-server.exe redis.windows.conf 命令即可,如下图所示:

到此,我们的redis数据库已经启动了,下面输出日志开启了服务链接在6379端口。

接下来我们来构建SpringBoot整合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
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- 引入Druid依赖 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.1.9</version>
</dependency>
<!-- 添加缓存支持 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<!-- 添加Redis缓存支持 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- 添加Jedis支持 -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.0</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<!--<scope>provided</scope>-->
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>

修改配置文件

配置redis, JPA, Druid

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
spring:
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf8
username: root
password: root

# 配置Druid
druid:
#配置控制统计拦截的filters,去掉后监控界面sql将无法统计, wall用于防火墙
filters: stat,wall
#最大活跃数
max-active: 20
#初始化数量
initial-size: 1
#最小连接池数量
min-idle: 1
#最大连接等待超时时间
max-wait: 60000
#打开PSCache,并且指定每个连接PSCache的大小,mysql可以配置为false
pool-prepared-statements: false
max-pool-prepared-statement-per-connection-size: 20
#通过connectionProperties属性来打开mergeSql功能;慢SQL记录
connection-properties: druid.stat.mergeSql=true;stat.slowSqlMillis=5000
#配置间隔多久才进行一次检测,检测需要关闭的空闲连接,单位是毫秒
time-between-eviction-runs-millis: 60000
#配置一个连接在池中最小生存的时间,单位是毫秒
min-evictable-idle-time-millis: 300000
#用来检测连接是否有效的sql
validation-query: SELECT 'x'
test-while-idle: true
test-on-borrow: false
test-on-return: false
async-init: true

# 配置JPA
jpa:
properties:
hibernate:
show_sql: true
format_sql: true

# 配置redis数据库连接
redis:
host: 127.0.0.1
port: 6379
jedis:
pool:
#最大连接数
max-active: 8
#最大阻塞等待时间(负数表示没限制)
max-wait: -1ms
#最大空闲
max-idle: 8
#最小空闲
min-idle: 0
#连接超时时间
timeout: 10000ms
#数据库索引
database: 0

配置CacheManager

让SpringBoot内置的缓存框架适用我们的Redis作为新的缓存, 添加一个RedisConfiguration的配置类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/**
* @author Ray
* @date 2018/7/25 0025
* 让SpringBoot内置的缓存框架使用我们的Redis作为新的缓存
* 使用@EnableCaching注解来开启我们的项目支持缓存
*/
@Configuration
@EnableCaching
public class RedisConfiguration {

/**
* 采用RedisCacheManager作为缓存管理器
* 为了处理高可用Redis,可以使用RedisSentinelConfiguration来支持Redis Sentinel。
*/
@Bean
public CacheManager cacheManager(RedisConnectionFactory connectionFactory){
RedisCacheManager redisCacheManager = RedisCacheManager.builder(connectionFactory).build();
return redisCacheManager;
}
}

实体类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
* @author Ray
* @date 2018/7/25 0025
*/
@Data
@Entity
@Table(name = "city")
public class City implements Serializable {

private static final long serialVersionUID = 7923962296287003563L;

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private String state;

}

数据访问层

1
2
3
4
@Repository
public interface CityDao extends JpaRepository<City, Long> {

}

数据控制层

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
* @author Ray
* @date 2018/7/25 0025
*/
@RestController
@RequestMapping("/cities")
public class CityController {

@Autowired
private CityDao cityDao;

@GetMapping("/")
public List<City> list(){
return cityDao.findAll();
}
}

测试Redis

访问地址: localhost:8080/cities/

再次访问地址: localhost:8080/cities/

可以看到只有一次输出, 这个输出还是我们上次访问的时候执行的, 证明我们配置的Redis缓存已经生效.

-------------- 本文结束  感谢您的阅读 --------------