在Spring Boot中使用数据缓存
2017-03-06 23:39
435 查看
春节就要到了,在回家之前要赶快把今年欠下的技术债还清。so,今天继续。spring Boot前面已经预热了n篇博客了,今天我们来继续看如何在Spring Boot中解决数据缓存问题。本篇博客是以初识在Spring
Boot中使用JPA为基础的,先了解如何实现数据访问,然后才好实现数据缓存。OK,对于Spring Boot尚有疑问的小伙伴可以先移步这里从SpringMVC到Spring Boot,老司机请略过。
OK,废话不多说,开始今天的技术之旅吧。
在实际开发中,对于要反复读写的数据,最好的处理方式是将之在内存中缓存一份,频繁的数据库访问会造成程序效率低下,同时内存的读写速度本身就要强于硬盘。Spring在这一方面给我们提供了诸多的处理手段,而Spring
Boot又将这些处理方式进一步简化,接下来我们就来看看如何在Spring Boot中解决数据缓存问题。
创建成功之后,接下来添加数据库驱动,我还是使用MySQL,在pom.xml中添加数据库驱动,如下:
2
3
4
5
1
2
3
4
5
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8
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
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
2
1
2
2
3
4
5
6
7
1
2
3
4
5
6
7
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
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
关于这个实现类我说如下几点:
1.@CachePut表示缓存新添加的数据或者更新的数据到缓存中,两个参数value表示缓存的名称为people,key表示缓存的key为person的id
2.@CacheEvict表示从缓存people中删除key为id的数据
3.@Cacheable表示添加数据到缓存中,缓存名称为people,缓存key为person的id属性。
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
OK ,做完这一切我们就可以来测试我们刚刚写的缓存了。
首先我们在浏览器中访问
这个时候查看控制台,输出内容如下:
说是数据已经被缓存了,这个时候我们再继续在浏览器中刷新继续请求id为1的数据,会发现控制台不会继续打印日志出来,就是因为数据已被存于缓存之中了。
接下来我们向浏览器中输入
这个时候查看控制台打印的日志如下:
再查看数据表,数据已插入成功:
此时,我们在浏览器中输入
这个时候查看控制台,发现并没有数据数据,就是因为数据已经处于缓存中了。
最后我们在浏览器中输入
这个时候查看控制台,已经提示缓存移除掉了:
同时数据也从数据库删除掉了,这个时候如果还需要该数据则需要我们继续向表中添加数据。
就这样就可以了。实际上在Spring Boot中,底层使用哪一种缓存我们并不必做过多考虑,切换的方式也很简单,如上文引入相应的依赖即可,我们只需要把上层的逻辑写好即可。
本文案例下载:
本文GitHub地址https://github.com/lenve/JavaEETest/tree/master/Test25-Cache.
更多Spring Boot案例请移步这里从SpringMVC到Spring Boot
Boot中使用JPA为基础的,先了解如何实现数据访问,然后才好实现数据缓存。OK,对于Spring Boot尚有疑问的小伙伴可以先移步这里从SpringMVC到Spring Boot,老司机请略过。
OK,废话不多说,开始今天的技术之旅吧。
在实际开发中,对于要反复读写的数据,最好的处理方式是将之在内存中缓存一份,频繁的数据库访问会造成程序效率低下,同时内存的读写速度本身就要强于硬盘。Spring在这一方面给我们提供了诸多的处理手段,而Spring
Boot又将这些处理方式进一步简化,接下来我们就来看看如何在Spring Boot中解决数据缓存问题。
创建Project并添加数据库驱动
Spring Boot的创建方式还是和我们前文提到的创建方式一样,不同的是这里选择添加的依赖不同,这里我们添加Web、Cache和JPA依赖,如下图:创建成功之后,接下来添加数据库驱动,我还是使用MySQL,在pom.xml中添加数据库驱动,如下:
<dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.40</version> </dependency>1
2
3
4
5
1
2
3
4
5
配置application.properties
这个application.properties的配置还是和初识在Spring Boot中使用JPA一样,各个参数的含义我这里也不再赘述,我们直接来看代码:spring.datasource.driver-class-name=com.mysql.jdbc.Driver spring.datasource.url=jdbc:mysql://localhost:3306/sang?useUnicode=true&characterEncoding=utf-8 spring.datasource.username=root spring.datasource.password=sang spring.jpa.hibernate.ddl-auto=update spring.jpa.show-sql=true spring.jackson.serialization.indent_output=true1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8
创建实体类
@Entity public class Person { @Id @GeneratedValue private Long id; private String name; private String address; private Integer age; public Person() { } public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getAddress() { return address; } public void setAddress(String address) { this.address = address; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } public Person(Long id, String name, String address, Integer age) { this.id = id; this.name = name; this.address = address; this.age = age; } }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
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
创建实体类的Repository
public interface PersonRepository extends JpaRepository<Person,Long> { }1
2
1
2
创建业务类
业务接口
public interface DemoService { public Person save(Person person); public void remove(Long id); public Person findOne(Person person); }1
2
3
4
5
6
7
1
2
3
4
5
6
7
实现类
@Service public class DemoServiceImpl implements DemoService { @Autowired PersonRepository personRepository; @CachePut(value = "people", key = "#person.id") @Override public Person save(Person person) { Person p = personRepository.save(person); System.out.println("为id、key为" + p.getId() + "数据做了缓存"); return p; } @CacheEvict(value = "people") @Override public void remove(Long id) { System.out.println("删除了id、key为" + id + "的数据缓存"); personRepository.delete(id); } @Cacheable(value = "people", key = "#person.id") @Override public Person findOne(Person person) { Person p = personRepository.findOne(person.getId()); System.out.println("为id、key为" + p.getId() + "数据做了缓存"); return p; } }@Service public class DemoServiceImpl implements DemoService { @Autowired PersonRepository personRepository; @CachePut(value = "people", key = "#person.id") @Override public Person save(Person person) { Person p = personRepository.save(person); System.out.println("为id、key为" + p.getId() + "数据做了缓存"); return p; } @CacheEvict(value = "people") @Override public void remove(Long id) { System.out.println("删除了id、key为" + id + "的数据缓存"); personRepository.delete(id); } @Cacheable(value = "people", key = "#person.id") @Override public Person findOne(Person person) { Person p = personRepository.findOne(person.getId()); System.out.println("为id、key为" + p.getId() + "数据做了缓存"); return p; } }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
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
关于这个实现类我说如下几点:
1.@CachePut表示缓存新添加的数据或者更新的数据到缓存中,两个参数value表示缓存的名称为people,key表示缓存的key为person的id
2.@CacheEvict表示从缓存people中删除key为id的数据
3.@Cacheable表示添加数据到缓存中,缓存名称为people,缓存key为person的id属性。
创建Controller
@RestController public class CacheController { @Autowired DemoService demoService; @RequestMapping("/put") public Person put(Person person) { return demoService.save(person); } @RequestMapping("/able") public Person cacheable(Person person) { return demoService.findOne(person); } @RequestMapping("/evit") public String evit(Long id) { demoService.remove(id); return "ok"; } }1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
OK ,做完这一切我们就可以来测试我们刚刚写的缓存了。
测试
看我们的Controller,我们有三个地址要测试,一个一个来。当然,在 测试之前,我们先来看看初始状态下的数据库是什么样子的:首先我们在浏览器中访问
http://localhost:8080/able?id=1,得到如下访问结果:
这个时候查看控制台,输出内容如下:
说是数据已经被缓存了,这个时候我们再继续在浏览器中刷新继续请求id为1的数据,会发现控制台不会继续打印日志出来,就是因为数据已被存于缓存之中了。
接下来我们向浏览器中输入
http://localhost:8080/put?age=47&name=奥巴牛&address=米国,访问结果如下:
这个时候查看控制台打印的日志如下:
再查看数据表,数据已插入成功:
此时,我们在浏览器中输入
http://localhost:8080/able?id=106,访问刚刚插入的这条数据,结果如下:
这个时候查看控制台,发现并没有数据数据,就是因为数据已经处于缓存中了。
最后我们在浏览器中输入
http://localhost:8080/evit?id=106,将数据从缓存中移除,访问结果如下:
这个时候查看控制台,已经提示缓存移除掉了:
同时数据也从数据库删除掉了,这个时候如果还需要该数据则需要我们继续向表中添加数据。
缓存技术切换
Spring Boot默认情况下使用ConcurrentMapCacheManager作为缓存技术,有的时候你可能想替换为其他的缓存方式,在Spring Boot中进行缓存的切换非常简单,我这里以Google提供的Guava为例,如果要使用这种缓存策略,只需要添加相应的依赖即可,如下:<dependency> <groupId>com.google.guava</groupId> <artifactId>guava</artifactId> <version>20.0</version> </dependency>
就这样就可以了。实际上在Spring Boot中,底层使用哪一种缓存我们并不必做过多考虑,切换的方式也很简单,如上文引入相应的依赖即可,我们只需要把上层的逻辑写好即可。
本文案例下载:
本文GitHub地址https://github.com/lenve/JavaEETest/tree/master/Test25-Cache.
更多Spring Boot案例请移步这里从SpringMVC到Spring Boot
相关文章推荐
- Spring Boot使用redis做数据缓存
- 在Spring Boot中如何使用数据缓存
- 在Spring Boot中使用数据缓存
- 在Spring Boot中使用数据缓存
- Spring Boot使用redis做数据缓存
- Spring Boot使用redis做数据缓存
- Spring Boot使用redis做数据缓存
- 在Spring Boot中使用数据缓存
- Spring Boot使用redis做数据缓存
- 在Spring Boot中使用数据缓存
- SpringBoot中使用数据缓存
- Spring Boot使用redis实现数据缓存
- 在Spring Boot中使用数据缓存
- Spring Boot 1.2.5使用redis做数据缓存
- Spring Boot使用redis做数据缓存
- 使用Spring Boot快速构建应用
- 使用 Spring Boot 快速构建 Spring 框架应用
- 开始使用Spring Boot
- Spring Boot 使用
- 使用Spring Boot和Gradle创建AngularJS项目