Spring Cache 入门

青旅半醒 2023-07-15 13:19 7阅读 0赞

很久之前收藏的一篇文章，后来找不到出处了

## 一：Spring缓存抽象 ##

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

*  Cache接口为缓存的组件规范定义，包含缓存的各种操作集合；
 *  Cache接口下Spring提供了各种xxxCache的实现；如RedisCache，EhCacheCache ,ConcurrentMapCache等；
 *  每次调用需要缓存功能的方法时，Spring会检查检查指定参数的指定的目标方法是否已经被调用过；如果有就直接从缓存中获取方法调用后的结果，如果没有就调用方法并缓存结果后返回给用户。下次调用直接从缓存中获取。
 *  使用Spring缓存抽象时我们需要关注以下两点：
    
    1.  确定方法需要被缓存以及他们的缓存策略
    2.  从缓存中读取之前缓存存储的数据

## 二：几个重要概念&缓存注解 ##

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th align="left">解释</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Cache</td> 
   <td align="left">缓存接口，定义缓存操作。实现有：RedisCache、EhCacheCache、ConcurrentMapCache等</td> 
  </tr> 
  <tr> 
   <td>CacheManager</td> 
   <td align="left">缓存管理器，管理各种缓存（cache）组件</td> 
  </tr> 
  <tr> 
   <td>@Cacheable</td> 
   <td align="left">主要针对方法配置，能够根据方法的请求参数对其进行缓存</td> 
  </tr> 
  <tr> 
   <td>@CacheEvict</td> 
   <td align="left">清空缓存</td> 
  </tr> 
  <tr> 
   <td>@CachePut</td> 
   <td align="left">保证方法被调用，又希望结果被缓存。与@Cacheable区别在于是否每次都调用方法，常用于更新</td> 
  </tr> 
  <tr> 
   <td>@EnableCaching</td> 
   <td align="left">开启基于注解的缓存</td> 
  </tr> 
  <tr> 
   <td>keyGenerator</td> 
   <td align="left">缓存数据时key生成策略</td> 
  </tr> 
  <tr> 
   <td>serialize</td> 
   <td align="left">缓存数据时value序列化策略</td> 
  </tr> 
  <tr> 
   <td>@CacheConfig</td> 
   <td align="left">统一配置本类的缓存注解的属性</td> 
  </tr> 
 </tbody> 
</table>

**@Cacheable/@CachePut/@CacheEvict 主要的参数**

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>解释</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>value</td> 
   <td>缓存的名称，在 spring 配置文件中定义，必须指定至少一个<br>例如：<br>@Cacheable(value=”mycache”) <br>或者@Cacheable(value={”cache1”,”cache2”}</td> 
  </tr> 
  <tr> 
   <td>key</td> 
   <td>缓存的 key，可以为空，如果指定要按照 SpEL 表达式编写，<br>如果不指定，则缺省按照方法的所有参数进行组合<br>例如：<br>@Cacheable(value=”testcache”,key=”#id”)</td> 
  </tr> 
  <tr> 
   <td>condition</td> 
   <td>缓存的条件，可以为空，使用 SpEL 编写，返回 true 或者 false，<br>只有为 true 才进行缓存/清除缓存<br>例如：@Cacheable(value=”testcache”,condition=”#userName.length()&gt;2”)</td> 
  </tr> 
  <tr> 
   <td>unless</td> 
   <td>否定缓存。当条件结果为TRUE时，就不会缓存。<br>@Cacheable(value=”testcache”,unless=”#userName.length()&gt;2”)</td> 
  </tr> 
  <tr> 
   <td>allEntries<br>(@CacheEvict )</td> 
   <td>是否清空所有缓存内容，缺省为 false，如果指定为 true,<br>则方法调用后将立即清空所有缓存<br>例如:<br>@CachEvict(value=”testcache”,allEntries=true)</td> 
  </tr> 
  <tr> 
   <td>beforeInvocation<br>(@CacheEvict)</td> 
   <td>是否在方法执行前就清空，缺省为 false，如果指定为 true，<br>则在方法还没有执行的时候就清空缓存，缺省情况下，如果方法<br>执行抛出异常，则不会清空缓存<br>例如：@CachEvict(value=”testcache”，beforeInvocation=true)</td> 
  </tr> 
 </tbody> 
</table>

## 三：SpEL上下文数据 ##

Spring Cache提供了一些供我们使用的SpEL上下文数据，下表直接摘自Spring官方文档：

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

**注意：**

1.当我们要使用root对象的属性作为key时我们也可以将“\#root”省略，因为Spring默认使用的就是root对象的属性。 如

`@Cacheable(key = "targetClass + methodName +#p0")`

2.使用方法参数时我们可以直接使用“\#参数名”或者“\#p参数index”。 如：

`@Cacheable(value="users", key="#id")`

`@Cacheable(value="users", key="#p0")`

**SpEL提供了多种运算符**

<table> 
 <thead> 
  <tr> 
   <th><strong>类型</strong></th> 
   <th><strong>运算符</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>关系</td> 
   <td>&lt;，&gt;，&lt;=，&gt;=，==，!=，lt，gt，le，ge，eq，ne</td> 
  </tr> 
  <tr> 
   <td>算术</td> 
   <td>+，- ，* ，/，%，^</td> 
  </tr> 
  <tr> 
   <td>逻辑</td> 
   <td>&amp;&amp;，</td> 
  </tr> 
  <tr> 
   <td>条件</td> 
   <td>?: (ternary)，?: (elvis)</td> 
  </tr> 
  <tr> 
   <td>正则表达式</td> 
   <td>matches</td> 
  </tr> 
  <tr> 
   <td>其他类型</td> 
   <td>?.，?[…]，![…]，<sup><a rel="nofollow">1</a></sup>，$[…]</td> 
  </tr> 
 </tbody> 
</table>

以上的知识点适合你遗忘的时候来查阅，下面正式进入学习！

## 四：开始使用 ##

环境：Spring boot 2.0.3

IDE：IDEA

### 1.开始使用前需要导入依赖 ###

<dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>

### 2.然后在启动类注解@EnableCaching开启缓存 ###

@SpringBootApplication
    @EnableCaching//开启缓存
    public class DemoApplication{ 
        public static void main(String[] args) { 
         SpringApplication.run(DemoApplication.class, args);
        }
    }

### 3.缓存@Cacheable ###

`@Cacheable`注解会先查询是否已经有缓存，有会使用缓存，没有则会执行方法并缓存。

@Cacheable(value = "emp" ,key = "targetClass + methodName +#p0")
    public List<NewJob> queryAll(User uid) { 
        return newJobDao.findAllByUid(uid);
    }

此处的`value`是必需的，它指定了你的缓存存放在哪块命名空间。

此处的`key`是使用的spEL表达式，参考上章。这里有一个小坑，如果你把`methodName`换成`method`运行会报错，观察它们的返回类型，原因在于`methodName`是`String`而`methoh`是`Method`。

此处的`User`实体类一定要实现序列化`public class User implements Serializable`，否则会报`java.io.NotSerializableException`异常。

到这里，你已经可以运行程序检验缓存功能是否实现。

**深入源码，查看它的其它属性**

我们打开`@Cacheable`注解的源码，可以看到该注解提供的其他属性，如：

String[] cacheNames() default { }; //和value注解差不多，二选一

String keyGenerator() default ""; //key的生成器。key/keyGenerator二选一使用

String cacheManager() default ""; //指定缓存管理器

String cacheResolver() default ""; //或者指定获取解析器

String condition() default ""; //条件符合则缓存

String unless() default ""; //条件符合则不缓存

boolean sync() default false; //是否使用异步模式

### 4.配置@CacheConfig ###

当我们需要缓存的地方越来越多，你可以使用`@CacheConfig(cacheNames = {"myCache"})`注解来统一指定`value`的值，这时可省略`value`，如果你在你的方法依旧写上了`value`，那么依然以方法的`value`值为准。

使用方法如下：

@CacheConfig(cacheNames = { "myCache"})
    public class BotRelationServiceImpl implements BotRelationService { 
        @Override
        @Cacheable(key = "targetClass + methodName +#p0")//此处没写value
        public List<BotRelation> findAllLimit(int num) { 
            return botRelationRepository.findAllLimit(num);
        }
    .....
    }

**查看它的其它属性**

String keyGenerator() default "";//key的生成器。key/keyGenerator二选一使用

String cacheManager() default "";//指定缓存管理器

String cacheResolver() default ""; //或者指定获取解析器

### 5.更新@CachePut ###

`@CachePut`注解的作用 主要针对方法配置，能够根据方法的请求参数对其结果进行缓存，和 `@Cacheable` 不同的是，它每次都会触发真实方法的调用 。简单来说就是用户更新缓存数据。但需要注意的是该注解的`value` 和 `key` 必须与要更新的缓存相同，也就是与`@Cacheable` 相同。示例：

@CachePut(value = "emp", key = "targetClass + #p0")
    public NewJob updata(NewJob job) { 
        NewJob newJob = newJobDao.findAllById(job.getId());
        newJob.updata(job);
        return job;
    }
    @Cacheable(value = "emp", key = "targetClass +#p0")//清空缓存
    public NewJob save(NewJob job) { 
        newJobDao.save(job);
        return job;
    }

**查看它的其它属性**

String[] cacheNames() default { }; //与value二选一

String keyGenerator() default "";//key的生成器。key/keyGenerator二选一使用

String cacheManager() default "";//指定缓存管理器

String cacheResolver() default ""; //或者指定获取解析器

String condition() default ""; //条件符合则缓存

String unless() default ""; //条件符合则不缓存

### 6.清除@CacheEvict ###

`@CachEvict` 的作用 主要针对方法配置，能够根据一定的条件对缓存进行清空 。

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>解释</th> 
   <th>示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>allEntries</td> 
   <td>是否清空所有缓存内容，缺省为 false，如果指定为 true，则方法调用后将立即清空所有缓存</td> 
   <td>@CachEvict(value=”testcache”,allEntries=true)</td> 
  </tr> 
  <tr> 
   <td>beforeInvocation</td> 
   <td>是否在方法执行前就清空，缺省为 false，如果指定为 true，则在方法还没有执行的时候就清空缓存，缺省情况下，如果方法执行抛出异常，则不会清空缓存</td> 
   <td>@CachEvict(value=”testcache”，beforeInvocation=true)</td> 
  </tr> 
 </tbody> 
</table>

示例：

@Cacheable(value = "emp",key = "#p0.id")
    public NewJob save(NewJob job) { 
        newJobDao.save(job);
        return job;
    }
    
    //清除一条缓存，key为要清空的数据
    @CacheEvict(value="emp",key="#id")
    public void delect(int id) { 
        newJobDao.deleteAllById(id);
    }
    
    //方法调用后清空所有缓存
    @CacheEvict(value="accountCache",allEntries=true)
    public void delectAll() { 
        newJobDao.deleteAll();
    }
    
    //方法调用前清空所有缓存
    @CacheEvict(value="accountCache",beforeInvocation=true)
    public void delectAll() { 
        newJobDao.deleteAll();
    }

**其他属性**

String[] cacheNames() default { }; //与value二选一
    
    String keyGenerator() default "";//key的生成器。key/keyGenerator二选一使用
    
    String cacheManager() default "";//指定缓存管理器
    
    String cacheResolver() default ""; //或者指定获取解析器
    
    String condition() default ""; //条件符合则清空

### 7.组合@Caching ###

有时候我们可能组合多个Cache注解使用，此时就需要@Caching组合多个注解标签了。

@Caching(cacheable = { 
        @Cacheable(value = "emp",key = "#p0"),
        ...
    },
    put = { 
        @CachePut(value = "emp",key = "#p0"),
        ...
    },evict = { 
        @CacheEvict(value = "emp",key = "#p0"),
        ....
    })
    public User save(User user) { 
        ....
    }

--------------------

1.  … ↩︎