前言

我知道在接口api项目中，频繁的调用接口获取数据，查询数据库是非常耗费资源的，于是就有了缓存技术，可以把一些不常更新，或者经常使用的数据，缓存起来，然后下次再请求时候，就直接从缓存中获取，不需要再去查询数据，这样可以提供程序性能，增加用户体验，也节省服务资源浪费开销，

在springboot帮你我们做好了整合，有对应的场景启动器start，我们之间引入使用就好了，帮我们整合了各种缓存

1    <dependencies>
2        <dependency>
3            <groupId>org.springframework.boot</groupId>
4            <artifactId>spring-boot-starter-cache</artifactId>
5        </dependency>
6    </dependencies>

简介

缓存介绍

Spring 从 3.1 开始就引入了对 Cache 的支持。定义了 org.springframework.cache.Cache 和 org.springframework.cache.CacheManager 接口来统一不同的缓存技术。并支持使用 JCache（JSR-107）注解简化我们的开发。

其使用方法和原理都类似于 Spring 对事务管理的支持。Spring Cache 是作用在方法上的，其核心思想是，当我们在调用一个缓存方法时会把该方法参数和返回结果作为一个键值对存在缓存中。

Cache 和 CacheManager 接口说明

Cache 接口包含缓存的各种操作集合，你操作缓存就是通过这个接口来操作的。 Cache 接口下 Spring 提供了各种 xxxCache 的实现，比如：RedisCache、EhCache、ConcurrentMapCache

CacheManager 定义了创建、配置、获取、管理和控制多个唯一命名的 Cache。这些 Cache 存在于 CacheManager 的上下文中。

小结

每次调用需要缓存功能的方法时，Spring 会检查指定参数的指定目标方法是否已经被调用过，如果有就直接从缓存中获取方法调用后的结果，如果没有就调用方法并缓存结果后返回给用户。下次调用直接从缓存中获取。

使用Spring缓存抽象时我们需要关注以下两点；

确定方法需要被缓存以及他们的缓存策略
从缓存中读取之前缓存存储的数据

快速开始

使用缓存我们需要开启基于注解的缓存，使用 @EnableCaching 标注在 springboot 主启动类上或者配置类上

1@SpringBootApplication
2@MapperScan(value = {"cn.soboys.kmall.mapper","cn.soboys.kmall.sys.mapper","cn.soboys.kmall.security.mapper"},nameGenerator = UniqueNameGenerator.class)
3@ComponentScan(value =  {"cn.soboys.kmall"},nameGenerator = UniqueNameGenerator.class)
4@EnableCaching  //开启缓存注解驱动，否则后面使用的缓存都是无效的
5public class WebApplication {
6    private static ApplicationContext applicationContext;
7
8    public static void main(String[] args) {
9        applicationContext =
10                SpringApplication.run(WebApplication.class, args);
11        //displayAllBeans();
12    }
13
14
15    /**
16     * 打印所以装载的bean
17     */
18    public static void displayAllBeans() {
19        String[] allBeanNames = applicationContext.getBeanDefinitionNames();
20        for (String beanName : allBeanNames) {
21            System.out.println(beanName);
22        }
23    }
24}

或者配置类

1/**
2 * @author kenx
3 * @version 1.0
4 * @date 2021/8/17 15:05
5 * @webSite https://www.soboys.cn/
6 * 自定义缓存配置
7 */
8@Configuration
9@Slf4j
10@EnableCaching  //开启缓存注解驱动，否则后面使用的缓存都是无效的
11public class CacheConfig {
12
13    //自定义配置类配置keyGenerator
14
15    @Bean("myKeyGenerator")
16    public KeyGenerator keyGenerator(){
17        return new KeyGenerator() {
18            @Override
19            public Object generate(Object target, Method method, Object... params) {
20                return method.getName()+"["+ Arrays.asList(params).toString() +"]";
21            }
22        };
23    }
24}

标注缓存注解在需要缓存的地方使用@Cacheable注解

1@CacheConfig(cacheNames = "menuCache",keyGenerator ="myKeyGenerator" )
2public interface IMenuService extends IService<Menu> {
3    /**
4     * 获取用户菜单信息
5     *
6     * @param username 用户名
7     * @return
8     */
9    @Cacheable(key = "#username")
10    List<Menu> getUserMenus(String username);
11}

@Cacheable注解有如下一些参数我们可以看到他源码

1@Target({ElementType.TYPE, ElementType.METHOD})
2@Retention(RetentionPolicy.RUNTIME)
3@Inherited
4@Documented
5public @interface Cacheable {
6    @AliasFor("cacheNames")
7    String[] value() default {};
8
9    @AliasFor("value")
10    String[] cacheNames() default {};
11
12    String key() default "";
13
14    String keyGenerator() default "";
15
16    String cacheManager() default "";
17
18    String cacheResolver() default "";
19
20    String condition() default "";
21
22    String unless() default "";
23
24    boolean sync() default false;
25}

下面介绍一下 @Cacheable 这个注解常用的几个属性：

cacheNames/value ：指定缓存组件的名字;将方法的返回结果放在哪个缓存中，是数组的方式，可以指定多个缓存；
key ：缓存数据时使用的 key，可以用它来指定。默认是使用方法参数的值。（这个 key 你可以使用 spEL 表达式来编写如 #i d;参数id的值 #a0 #p0 #root.args[0]）
keyGenerator ：key的生成器；可以自己指定key的生成器的组件id 然后key 和 keyGenerator 二选一使用
cacheManager ：可以用来指定缓存管理器。从哪个缓存管理器里面获取缓存。或者cacheResolver指定获取解析器
condition ：可以用来指定符合条件的情况下才缓存

1condition = "#id>0"
2condition = "#a0>1"：第一个参数的值》1的时候才进行缓存

unless ：否定缓存。当 unless 指定的条件为 true ，方法的返回值就不会被缓存。当然你也可以获取到结果进行判断。（通过 #result 获取方法结果）

1unless = "#result == null"
2unless = "#a0==2":如果第一个参数的值是2，结果不缓存；

sync ：是否使用异步模式。异步模式的情况下unless不支持默认是方法执行完，以同步的方式将方法返回的结果存在缓存中

cacheNames/value属性

用来指定缓存组件的名字，将方法的返回结果放在哪个缓存中，可以是数组的方式，支持指定多个缓存

1 /**
2     * 获取用户菜单信息
3     *
4     * @param username 用户名
5     * @return
6     */
7    @Cacheable(cacheNames = "menuCache") 或者// @Cacheable(cacheNames = {"menuCache","neCacge"})
8    List<Menu> getUserMenus(String username);

如果只有一个属性，cacheNames可忽略，直接是value属性默认

key

缓存数据时使用的 key。默认使用的是方法参数的值。可以使用 spEL 表达式去编写。

Cache SpEL available metadata

名称	位置	描述	示例
methodName	root对象	当前被调用的方法名	#root.methodname
method	root对象	当前被调用的方法	#root.method.name
target	root对象	当前被调用的目标对象实例	#root.target
targetClass	root对象	当前被调用的目标对象的类	#root.targetClass
args	root对象	当前被调用的方法的参数列表	#root.args[0]
caches	root对象	当前方法调用使用的缓存列表	#root.caches[0].name
argumentName	执行上下文(avaluation context)	当前被调用的方法的参数，如findArtisan(Artisan artisan),可以通过#artsian.id获得参数	#artsian.id
result	执行上下文(evaluation context)	方法执行后的返回值（仅当方法执行后的判断有效，如 unless cacheEvict的beforeInvocation=false）	#result

1//key = "#username" 就是参数username
2 @Cacheable(key = "#username" ,cacheNames = "menuCache")
3List<Menu> getUserMenus(String username);

keyGenerator

key 的生成器，可以自己指定 key 的生成器，通过这个生成器来生成 key

定义一个@Bean类，将KeyGenerator添加到Spring容器

1@Configuration
2@Slf4j
3@EnableCaching  //开启缓存注解驱动，否则后面使用的缓存都是无效的
4public class CacheConfig {
5
6    //自定义配置类配置keyGenerator
7
8    @Bean("myKeyGenerator")
9    public KeyGenerator keyGenerator(){
10        return new KeyGenerator() {
11            @Override
12            public Object generate(Object target, Method method, Object... params) {
13                return method.getName()+"["+ Arrays.asList(params).toString() +"]";
14            }
15        };
16    }
17}

在使用指定自己的@Cacheable(cacheNames = "menuCache",keyGenerator ="myKeyGenerator" )

注意这样放入缓存中的 key 的生成规则就按照你自定义的 keyGenerator 来生成。不过需要注意的是：@Cacheable 的属性，key 和 keyGenerator 使用的时候，一般二选一。

condition

符合条件的情况下才缓存。方法返回的数据要不要缓存，可以做一个动态判断。

1 /**
2     * 获取用户菜单信息
3     *
4     * @param username 用户名
5     * @return
6     */
7    //判断username 用户名是kenx开头才会被缓存
8    @Cacheable(key = "#username" ,condition = "#username.startsWith('kenx')")
9    List<Menu> getUserMenus(String username);

unless

否定缓存。当 unless 指定的条件为 true ，方法的返回值就不会被缓存。

1 /**
2     * 获取用户菜单信息
3     *
4     * @param username 用户名
5     * @return
6     */
7    //判断username 用户名是kenx开头不会被缓存
8    @Cacheable(key = "#username" ,condition = "#username.startsWith('kenx')")
9    List<Menu> getUserMenus(String username);

spEL 编写 key

当然我们可以全局去配置，cacheNames，keyGenerator属性通过@CacheConfig注解可以用于抽取缓存的公共配置，然后在类加上就可以，eg：如

1//全局配置，下面用到缓存方法，不配置默认使用全局的
2@CacheConfig(cacheNames = "menuCache",keyGenerator ="myKeyGenerator" )
3public interface IMenuService extends IService<Menu> {
4    /**
5     * 获取用户菜单信息
6     *
7     * @param username 用户名
8     * @return
9     */
10    @Cacheabl
11    List<Menu> getUserMenus(String username);
12}
13

深入使用

@CachePut

@CachePut注解也是一个用来缓存的注解，不过缓存和@Cacheable有明显的区别是即调用方法，又更新缓存数据，也就是执行方法操作之后再来同步更新缓存，所以这个主键常用于更新操作，也可以用于查询，主键属性和@Cacheable有很多类似的参看 @CachePut源码

1@Target({ElementType.TYPE, ElementType.METHOD})
2@Retention(RetentionPolicy.RUNTIME)
3@Inherited
4@Documented
5public @interface CachePut {
6    @AliasFor("cacheNames")
7    String[] value() default {};
8
9    @AliasFor("value")
10    String[] cacheNames() default {};
11
12    String key() default "";
13
14    String keyGenerator() default "";
15
16    String cacheManager() default "";
17
18    String cacheResolver() default "";
19
20    String condition() default "";
21
22    String unless() default "";
23}

1/**
2     *  @CachePut：既调用方法，又更新缓存数据；同步更新缓存
3     *  修改了数据，同时更新缓存
4     */
5    @CachePut(value = {"emp"}, key = "#result.id")
6    public Employee updateEmp(Employee employee){
7        employeeMapper.updateEmp(employee);
8        LOG.info("更新{}号员工数据",employee.getId());
9        return employee;
10    }

@CacheEvict

清空缓存主要属性：

key：指定要清除的数据
allEntries = true：指定清除这个缓存中所有的数据
beforeInvocation = false：默认代表缓存清除操作是在方法执行之后执行
beforeInvocation = true：代表清除缓存操作是在方法运行之前执行

1@CacheEvict(value = {"emp"}, beforeInvocation = true,key="#id")
2    public void deleteEmp(Integer id){
3        employeeMapper.deleteEmpById(id);
4        //int i = 10/0;
5    }

@Caching

@Caching 用于定义复杂的缓存规则，可以集成@Cacheable和 @CachePut

1// @Caching 定义复杂的缓存规则
2    @Caching(
3            cacheable = {
4                    @Cacheable(/*value={"emp"},*/key = "#lastName")
5            },
6            put = {
7                    @CachePut(/*value={"emp"},*/key = "#result.id"),
8                    @CachePut(/*value={"emp"},*/key = "#result.email")
9            }
10    )
11    public Employee getEmpByLastName(String lastName){
12        return employeeMapper.getEmpByLastName(lastName);
13    }
14

@CacheConfig

@CacheConfig注解可以用于抽取缓存的公共配置，然后在类加上就可以

1//全局配置，下面用到缓存方法，不配置默认使用全局的
2@CacheConfig(cacheNames = "menuCache",keyGenerator ="myKeyGenerator" )
3public interface IMenuService extends IService<Menu> {
4    /**
5     * 获取用户菜单信息
6     *
7     * @param username 用户名
8     * @return
9     */
10    @Cacheable(key = "#username" )
11    List<Menu> getUserMenus(String username);
12}

参考

SpringBoot 整合缓存Cacheable实战详细使用

前言

简介