Spring Boot学习(十):Spring Boot 与缓存

这里是一个学习过程笔记的汇总:Spring Boot学习汇总

缓存,我们应该已经很熟悉了。那么今天就来学习一下Spring Boot中怎么使用缓存。

1、说起缓存,先来了解下JSR107

首先什么是JSR?

        JSR是Java Specification Requests 的缩写 ,Java规范请求,故名思议提交Java规范,大家一同遵守这个规范的话,会让大家‘沟通’起来更加轻松。

什么是JSR107?

        JSR107就是如何使用缓存的规范。

JSR107都有哪些内容?

        可以看一下JSR107官网

        核心API:

  • CachingProvider:定义了建立,配置,得到,管理和控制0个或多个CacheManager,一个应用在运行时可能访问0个或者多个CachingProvider。
  • CacheManager:它定义了建立,配置,得到,管理和控制0个或多个有着唯一名字的Cache ,一个CacheManager被包含在单一的CachingProvider。

  •  Cache:Cache是一个Map类型的数据结构,用来存储基于键的数据,很多方面都像java.util.Map数据类型。一个Cache 存在在单一的CacheManager。

  •  Entry:Entry是一个存在在Cache的键值对。

  • ExpiryPolicy:不是所有的数据都一直存在缓存中不改变的,为缓存的数据添加过期的策略会让你的缓存更加灵活和高效。

     相应的关系可以参考下图:

Spring Boot学习(十):Spring Boot 与缓存_第1张图片

2、Spring Boot的缓存机制

2.1、创建项目

参考上一篇文章,Spring Boot整合mybatis,快速创建一个Spring Boot项目(除web, mysql, mybatis之外多添加一个cache模块),如下:

Spring Boot学习(十):Spring Boot 与缓存_第2张图片

创建好之后,看一下pom文件,会看到引入了cache模块:

Spring Boot学习(十):Spring Boot 与缓存_第3张图片

项目结构:

Spring Boot学习(十):Spring Boot 与缓存_第4张图片

2.2、完善项目结构并测试

这个项目我们不使用mapper配置文件,我们基于mapper注解的方式进行访问。

创建表user,并插入两条数据:

CREATE TABLE `user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `age` int(4) NOT NULL,
  `name` varchar(20) COLLATE utf8mb4_unicode_ci NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci

实体类User:

package com.example.cache.domain;

import org.springframework.stereotype.Component;

import java.io.Serializable;

/**
 * @author pavel
 * @date 2018/11/19 0019
 */
@Component
public class User implements Serializable {

    private static final long serialVersionUID = -1274433079373420955L;

    private Long id;
    private Integer age;
    private String name;

    public User() {

    }

    public User(Long id, Integer age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

mapper接口:

package com.example.cache.mapper;

import com.example.cache.domain.User;
import org.apache.ibatis.annotations.*;

/**
 * 基于注解的mapper配置
 * @author pavel
 * @date 2018/11/19 0019
 */
@Mapper
public interface UserMapper {

    @Select("select * from user where id = #{id}")
    User getUser(Long id);

    @Update("update user set name = #{name},age = #{age} where id = #{id}")
    void updateUser(User user);

    @Delete("delete from user where id = #{id}")
    void deleteUser(Long id);

    @Insert("insert into user(age,name) values(#{age},#{name}) ")
    void insertUser(User user);


}

service:

package com.example.cache.service;

import com.example.cache.domain.User;
import com.example.cache.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

/**
 * @author pavel
 * @date 2018/11/22 0022
 */
@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;
    
    public User getUser(Long id) {
        System.out.println("查询" + id + "号员工");
        return userMapper.getUser(id);
    }
}

启动类上添加mapper的包扫描:

package com.example.cache;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.example.cache.mapper")
public class SpringBootCacheApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringBootCacheApplication.class, args);
    }
}

主配置文件中的数据库连接配置:

### database ###
spring.datasource.url=jdbc:mysql://localhost:3306/springboot_test?characterEncoding=utf-8&useSSL=false&serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=yjx941001
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

### 控制台打印sql ###
logging.level.com.example.cache.mapper = debug

controller:

package com.example.cache.controller;

import com.example.cache.domain.User;
import com.example.cache.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author pavel
 * @date 2018/11/19 0019
 */
@RestController
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/user/{id}")
    public User getUser(@PathVariable("id") Long id) {
        User user = userService.getUser(id);
        System.out.println("查询结果: " + user);
        return user;
    }
}

启动项目,浏览器请求:http://localhost:8080/user/1

控制台:

浏览器再次请求:http://localhost:8080/user/1

Spring Boot学习(十):Spring Boot 与缓存_第5张图片

可以发现"查询1号员工"字样会打印两次,说明第二次访问再次调用了查询方法,访问数据库,此时没有任何缓存机制。

2.3、加入缓存机制

修改启动类,添加@EnableCaching注解,开启缓存机制:

package com.example.cache;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;

@SpringBootApplication
@EnableCaching
@MapperScan("com.example.cache.mapper")
public class SpringBootCacheApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootCacheApplication.class, args);
    }
}

修改service,给getUser方法加上@Cacheable注解(下面再详细介绍这个注解的作用),如下:

package com.example.cache.service;

import com.example.cache.domain.User;
import com.example.cache.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

/**
 * @author pavel
 * @date 2018/11/22 0022
 */
@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    @Cacheable(cacheNames = "user")
    public User getUser(Long id) {
        System.out.println("查询" + id + "号员工");
        return userMapper.getUser(id);
    }
}

重启,然后请求http://localhost:8080/user/1,控制台输出:

再次请求:

Spring Boot学习(十):Spring Boot 与缓存_第6张图片

看控制台输出,第一次请求,打印出“查询1号员工”字样、查询sql以及查询结果,但第二次请求,只打印了查询结果,并没有“查询1号员工”字样以及查询sql,说明我们配置的缓存是生效的,第二次请求是直接从缓存中获取user对象。

3、工作原理及运行流程
    3.1、工作原理

       缓存我们引入了cache模块, 还是之前讲到过的Spring Boot自动配置原理,有一系类的xxxAutoConfiguration配置类,那么肯定会有cache相关的自动配置,即:CacheAutoConfiguration,所以我们就进去看一下。

Spring Boot学习(十):Spring Boot 与缓存_第7张图片

        看到会给容器导入一个CacheConfigurationImportSelector选择器,debug看一下:

Spring Boot学习(十):Spring Boot 与缓存_第8张图片

这里就是导入的所有的缓存配置。但不是都生效,又兴趣的话可以每一个点进去看一下,看在什么情况下那个配置才会生效。

可以在配置文件中配置: debug=true

然后看到控制台输出中,默认是 SimpleCacheConfiguration会生效。所以我们就之间去看这个缓存配置类:

Spring Boot学习(十):Spring Boot 与缓存_第9张图片

如上图,可以看出,这个配置类,就是给容器注册了一个CacheManager:ConcurrentMapCacheManager

我们再看下这个ConcurrentMapCacheManager:

实现了CacheManager接口,那么就有了关于Cache相关的操作方法,比如getCache()

Spring Boot学习(十):Spring Boot 与缓存_第10张图片

我们请求http://localhost:8080/user/1,dubug运行一下看

Spring Boot学习(十):Spring Boot 与缓存_第11张图片

所以说,ConcurrentMapCacheManager的作用是创建和获取ConcurrentMapCache类型的缓存组件。

我们继续看,怎么创建的Cache,如下,直接new ConcurrentMapCache();

再往下走,进到ConcurrentMapCache类,这个就是缓存组件类,

Spring Boot学习(十):Spring Boot 与缓存_第12张图片

类中有两个方法,put(Object key, @Nullable Object value) 以及lookup(Object key)方法,如下:

Spring Boot学习(十):Spring Boot 与缓存_第13张图片

我们可以debug看一下,重启,浏览器访问 http://localhost:8080/user/1

可见,key的值就是1,

Spring Boot学习(十):Spring Boot 与缓存_第14张图片

lookup()方法返回值为null,说明缓存中没有这个对象,再往下走,就进入到了getUser()方法进行查询,然后再进到put()方法,将查询结果以key-value的方式存到缓存中,key是请求参数1,而value就是查询结果-User对象:

Spring Boot学习(十):Spring Boot 与缓存_第15张图片

下面再次请求,http://localhost:8080/user/1

Spring Boot学习(十):Spring Boot 与缓存_第16张图片

进入到lookup()方法,可以看到,this.store中有值,key是1,value是一个User对象,正是上一步访问后存入到缓存中的User对象,所以,再次访问就能够直接从缓存中获取到值了。

缓存的工作原理就是这个样子了,可以自己debug一步一步的看。

3.2、运行流程

@Cacheable的运行流程:
        (1) 该注解时作用于方法之上的,在方法运行之前,会先去查询Cache(缓存组件),按照cacheNames/value指定的名字获取,(cacheManager先获取相应的缓存),第一次获取缓存如果没有Cache组件会自动创建。

        (2) 去Cache中查找缓存的内容,使用一个key,key默认值就是方法的参数。

                key是按照某种策略生成的;默认是使用keyGenerator接口的实现类SimpleKeyGenerator生成;

                SimpleKeyGenerator的生成key的默认策略(debug一步一步可以看到的):

                                       如果没有参数: key = new SimpleKey()

                                       如果有一个参数:key = 参数的值

                                       如果有多个参数:key = new SimpleKey(params)
        (3) 没有查到缓存就调用目标方法 (也就是上面例子中的getUser()方法)
        (4) 将目标方法返回的结果放到缓存中

4、@Cacheable注解详解


注解@Cacheable的相关属性:
               cacheNames/value: 指定缓存组件的名字;将结果放到哪个缓存组件中,可以用数组的形式指定多个缓存组件
               key:缓存数据使用的key,  默认使用的是方法参数的值 id-方法返回值
               keyGenerator: key的生成器,可以自己指定key的生成器的组件id 

                                 key/keyGenerator:二选一使用
               cacheManager:指定缓存管理器,  或者指定cacheResovler指定获取解析器
               condition: 指定符合条件的情况下才缓存  
               unless: 否定缓存,当unless指定的条件为true时,方法的返回值不回被缓存。 
               sync:是否使用异步模式

接下来一个一个来尝试:
cacheNames:我们在上面的例子已经使用到了,用value是一样的效果,都是给缓存组件指定一个名字。
key: 缓存数据使用的key,不设置的话默认是使用方法参数,上面已经说过了。

         我们还可以自己设置key的值,利用SpEL表达式,那么缓存中可以写的SpEL如下图所示:

Spring Boot学习(十):Spring Boot 与缓存_第17张图片

下面就来自己定义一个key的值,比如我想将key设置为:方法名[参数值],则如下拼接,根据上图看到,#root.methodName就是方法名,#id就是参数值:

Spring Boot学习(十):Spring Boot 与缓存_第18张图片

重启项目,然后访问 http://localhost:8080/user/1

Spring Boot学习(十):Spring Boot 与缓存_第19张图片

可以看到,生成的key就是我们自己设置的:方法名[参数值]

keyGenerator: 这个就是一个key生成器,自己写一个就是,如下:

package com.example.cache.config;

import org.springframework.cache.interceptor.KeyGenerator;

import java.lang.reflect.Method;
import java.util.Arrays;

/**
 * @author pavel
 * @date 2018/11/22 0022
 */
@Configuration
public class MyCacheConfig {

    @Bean("myKeyGenerator")
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                return method.getName() + "[" + Arrays.asList(params).toString() + "]";
            }
        };
    }
}

然后在方法上指定keyGenerator:

Spring Boot学习(十):Spring Boot 与缓存_第20张图片

重启项目,访问http://localhost:8080/user/1

Spring Boot学习(十):Spring Boot 与缓存_第21张图片

如上图,生成的key为:getUser()[ [1] ],多一层[]是Arrays.asList()产生的。

cacheManager: 指定缓存管理器,这个后面我们使用多个缓存管理器时再讨论。

condition: 指定符合条件的情况下才缓存;比如我指定当参数id大于1的时候才缓存:condition = "#id>1",如下:

Spring Boot学习(十):Spring Boot 与缓存_第22张图片

重启,然后连续两次访问:http://localhost:8080/user/1,结果如下:

Spring Boot学习(十):Spring Boot 与缓存_第23张图片

可以看到,连续两次请求,获取id为1 的用户,都会调用方法发送sql语句查询,第一次的查询结果并没有被缓存,

那么再看连续两次请求获取id为2的用户,http://localhost:8080/user/2 控制台输出如下:

Spring Boot学习(十):Spring Boot 与缓存_第24张图片

可见,第一次请求的结果进行的缓存。

unless: 否定缓存,当unless指定的条件为true,方法的返回值就不会被缓存。例如:unless = "#id == 2", 当参数id为2时就不进行缓存。

Spring Boot学习(十):Spring Boot 与缓存_第25张图片

重启,然后连续两次请求 http://localhost:8080/user/2

Spring Boot学习(十):Spring Boot 与缓存_第26张图片

控制台两次请求都调用方法并发送sql进行查询。

再连续两次请求 http://localhost:8080/user/1

Spring Boot学习(十):Spring Boot 与缓存_第27张图片

只是第一次请求调用了方法并发送sql进行查询。

sync:是否使用异步模式。sync=true   

  看源码,默认是false,使用异步模式就不支持unless了,这个就自己试一下吧。如下:

Spring Boot学习(十):Spring Boot 与缓存_第28张图片

5、@Cacheput注解

作用:修改数据库数据,并同步更新缓存。  这就避免了更新了数据库的数据(数据已加入缓存)后再次查询还是查到更新前的数据。

运行时机:

        1、先调用目标方法

        2、将目标方法的结果缓存起来 

下面就来使用一下这个注解。给上面的UserService中增加一个updateUser方法,方法上使用@Cacheput注解,并返回修改后的User对象, 如下:

package com.example.cache.service;

import com.example.cache.domain.User;
import com.example.cache.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

/**
 * @author pavel
 * @date 2018/11/22 0022
 */
@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    @Cacheable(cacheNames = "user")
    public User getUser(Long id) {
        System.out.println("查询" + id + "号员工");
        return userMapper.getUser(id);
    }


    @CachePut
    public User updateUser(User user) {
        System.out.println("更新" + user.getId() + "号员工");
        userMapper.updateUser(user);
        return user;
    }
}

UserController中增加updateUser方法:

package com.example.cache.controller;

import com.example.cache.domain.User;
import com.example.cache.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author pavel
 * @date 2018/11/19 0019
 */
@RestController
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/user/{id}")
    public User getUser(@PathVariable("id") Long id) {
        User user = userService.getUser(id);
        System.out.println("查询结果: " + user);
        return user;
    }

    @GetMapping("/user")
    public User updateUser(User user) {
        User u = userService.updateUser(user);
        System.out.println("更新后结果:" + u);
        return u;
    }
}

下面我们来测试一下,先说一下测试流程:

        1、查询1号用户,查到的结果会放到缓存中:http://localhost:8080/user/1

        2、再次查询1号用户,还是之前的结果

        3、更新1号用户,http://localhost:8080/user?id=1&name=xinanxin&age=25

        4、再次查询1号用户,那么,会不会查询数据库?返回的是更新前的用户还是更新后的用户?

启动项目,按照以上测试流程逐步进行,控制台输出结果如下:

Spring Boot学习(十):Spring Boot 与缓存_第29张图片

上体可以看到,步骤3确实是更新了数据库,但是步骤4再次查询时,没有发送查询sql,但是查询结果确实更新前的数据,这是 怎么回事?难道@Cacheput没起作用?

回头看一下我们UserService中的两个方法,查询和更新,我们都没有设置缓存数据的key,所以都默认以参数为key,

那么上面步骤1执行之后,缓存中:key = id  value = User对象

              步骤3执行之后,缓存中:key = 传入的User对象 value = 返回的User对象

这下明白了吧,我们更新操作之后,返回的更新后的数据其实是存入到了缓存中,但是存入的key同样是一个User对象而不是id。

下面将updateUser()方法做下修改,设置key值为传入User对象的id或者是返回User对象的id:

   @CachePut(cacheNames = "user", key = "#user.id")    // 或者key = "#result.id"
    public User updateUser(User user) {
        System.out.println("更新" + user.getId() + "号员工");
        userMapper.updateUser(user);
        return user;
    }

这样修改之后,查询和更新的方法,key值都是User对象的id了。

再次测试以上四个步骤,此时数据库中id为1的数据是:【name=xinanxin, age=25】,将其修改为【name=curry, age=31】

控制台输出如下:

Spring Boot学习(十):Spring Boot 与缓存_第30张图片

可以看到,步骤4查询出来的就是修改后的user对象了。有兴趣的话,可以debug一步步的看一下源码,是怎么进行缓存中数据更新的。

6、@CacheEvict注解

作用:缓存清除。一般用在删除的方法上,删除数据后,进行缓存清除

相关属性:

        key: 指定要清除的数据

        allEntries: 默认是false,若设置为true,则清除该Cache中的所有缓存数据。

        beforeInvocation: 默认是false, 代表缓存的清除是在方法调用之后进行的,如果方法出现异常,则缓存不会被清除,若设置为true,则代表缓存的清除是在方法调用之前进行的,不论该方法的执行是否会出现异常,缓存都会被清除。

 这个注解,案例就不详细写了啊,可以参考上面的查询和修改,写上一个delete方法测试。

7、@Caching注解

作用:定义复杂的缓存规则。是一个组合注解,里面可以包括以上介绍的三个注解。如下:

Spring Boot学习(十):Spring Boot 与缓存_第31张图片

我们同样来写一个案例,使用一下这个注解.

在UserMapper接口增加方法,getUser=ByName()

    @Select("select * from user where name = #{name}")
    User getUserByName(String name);

在UserService中增加方法,getUserByUserName():

  @Caching(
            cacheable = {
                    @Cacheable(cacheNames = "user")
            },
            put = {
                    @CachePut(cacheNames = "user", key = "#result.id"),
                    @CachePut(cacheNames = "user", key = "#result.age")
            }
    )
    public User getUserByName(String name) {
        System.out.println("通过name查找User");
        return userMapper.getUserByName(name);
    }

在这个方法上,加上了@Caching注解,里面包含了caccheable和put,cacheable给缓存中添加的数据key为name,value为User对象, put给缓存添加的数据key是 id和 age,value为User对象。

等于说,调用了这个方法之后,再根据id,age去查询,就不用查询数据库了,直接从缓存中取。

但是根据name查询,还是会发送sql进行数据库查询,因为使用了@CachePut注解,使用这个注解每次都会调用方法。

 

在UserController中增加getUserByUserName()

    @GetMapping("/user/find-by-name")
    public User getUserByName(@RequestParam("name") String name) {
        User user = userService.getUserByName(name);
        System.out.println("getUserByName()查询结果: " + user);
        return user;
    }

下面来测试一下,测试流程:

        1、根据name访问 http://localhost:8080/user/find-by-name?name=pavel

        2、根据id访问 http://localhost:8080/user/1(可以自己写个根据age访问,这里省略)

        3、再根据name访问 http://localhost:8080/user/find-by-name?name=pavel

重启,然后依次执行上面步骤,控制台输出如下:

Spring Boot学习(十):Spring Boot 与缓存_第32张图片

通过控制台输出可以看到,步骤1通过name查询,发送sql查询,步骤2再通过id查询(或者是自己写的通过age查询),都不会发送sql查数据库,而是直接从缓存中取的,步骤3再次通过name查询时,还是发送了sql查询,说明加上@CachePut后,每次调用都会查询数据库。

8、@CacheConfig注解

这是全局缓存配置,作用在类上面,对整个类生效。看下这个注解都有哪些内容:

Spring Boot学习(十):Spring Boot 与缓存_第33张图片

可以设置缓存名称,key生成器,缓存管理器,以及缓存解析器

比如在上面讲@Caching注解的案例中,我们将缓存数据都添加到了名为user的Cache中,所以我们配置了三次 cacheNames = "user",这样很繁琐,那么可以在类上面使用@CacheConfig(cacheNames = "user") 来简化,如下:

package com.example.cache.service;

import com.example.cache.domain.User;
import com.example.cache.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.*;
import org.springframework.stereotype.Service;

/**
 * @author pavel
 * @date 2018/11/22 0022
 */
@Service
@CacheConfig(cacheNames = "user")
public class UserService {

    @Autowired
    private UserMapper userMapper;

    @Cacheable()
    public User getUser(Long id) {
        System.out.println("查询" + id + "号员工");
        return userMapper.getUser(id);
    }


    @CachePut(key = "#user.id")    // 或者key = "#result.id"
    public User updateUser(User user) {
        System.out.println("更新" + user.getId() + "号员工");
        userMapper.updateUser(user);
        return user;
    }

    @CacheEvict()
    public void deleteUser(Long id) {
        System.out.println("删除"+ id + "号员工");
        userMapper.deleteUser(id);
    }

    @Caching(
            cacheable = {
                    @Cacheable()
            },
            put = {
                    @CachePut(key = "#result.id"),
                    @CachePut(key = "#result.age")
            }
    )
    public User getUserByName(String name) {
        System.out.println("通过name查找User");
        return userMapper.getUserByName(name);
    }
}

这样,效果是一样的,可以自己尝试一下。

 

好了,我关于Spring Boot的缓存相关内容的学习就是如上这些了,以后再深入学习的再补充过来。

希望对刚研究这块的小伙伴能有一点点帮助。

你可能感兴趣的:(spring,boot,学习)