【SpringBoot】集成缓存抽象层SpringCache进行项目实战

男娘i 2022-09-08 05:57 321阅读 0赞

### 文章目录 ###

*  一.前言
 *   *  1.JSR107
     *  2.合理使用缓存
     *  3.SpringCache介绍
     *  4.Spring支持的CacheManager
     *  5.SpringBoot的配置支持
 *  二.声明式缓存注解
 *   *  0.几个重要概念&缓存注解
     *  1.@CacheConfig
     *  2.@Cacheable
     *  3.@CachePut
     *  4.@CacheEvict
     *  6.使用SpEL获取元数据
     *  5.@Caching
     *  6. 使用注意
     *  7.高级redis客户端
     *  8.缓存key的设置
     *  9.同步缓存
     *  10.条件缓存
 *  三.SpringBoot整合Redis做为缓存组件
 *   *  1.引入依赖
     *  2.配置数据源和redis
     *  3.启动类开启SpringCache
     *  4.自定义缓存配置
     *   *  普通配置类
         *  或者继承CachingConfigurerSupport类
     *  5.编写缓存处理类
 *  四.SpringBoot整合EhCache3做缓存组件
 *   *  1.引入依赖
     *  2.创建ehcache3的配置文件ehcache.xml
     *  3. 在application.yml中加入以下配置代码
     *  4.启动类开启SpringCache(同引入Redis代码)
     *  5.编写缓存处理类(同引入Redis代码)
 *  五.SpringBoot整合Caffeine做缓存组件
 *   *  1.引入依赖
     *  2. 在application.yml中加入以下配置代码
     *  3. 启动类开启SpringCache(同引入Redis代码)
     *  4. 编写缓存处理类(同引入Redis代码)
 *  六.SpingCache缺点
 *  七.SpingCache源码解析(后续补充)

# 一.前言 #

> 计算机领域有人说过一句名言：“计算机科学领域的任何问题都可以通过增加一个中间层来解决”，今天我们就用Spring-cache给网站添加一层缓存，让网站速度飞起来。

## 1.JSR107 ##

`Java Caching`定义了**5个核心接口**，分别是`CachingProvider、CacheManager、 Cache、Entry 、 Expiry`

1.  **CachingProvider**：定义了**创建、配置、获取、管理和控制多个CacheManager的接口**。`一个应用可以在运行期访问多个CachingProvider。`
2.  **CacheManager**：定义了**创建、配置、获取、管理和控制多个唯一命名的Cache的接口**，**这些Cache 存在于CacheManager的上下文中**。`一个CacheManager仅被一个CachingProvider所拥有。`
3.  **Cache**：是一个类似`Map的数据结构`并临时存储以Key为索引的值`。一个Cache仅被一个 CacheManager所拥有`。
4.  **Entry**：是一个`存储在Cache中的key-value对`。
5.  **Expiry** ：每一个存储在Cache中的数据都有一个有效期。一旦超过这个时间，数据为过期 的状态。一旦过期，数据将不可访问、更新和删除。`缓存有效期可以通过ExpiryPolicy设置。`  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aKp5aKp5YiG5aKp_size_20_color_FFFFFF_t_70_g_se_x_16]

## 2.合理使用缓存 ##

**合理使用缓存**

*  缓存的目的主要是为了降低数据库的压力，服务可以直接从缓存中获取数据，从而提高响应速度，让原本有限的资源可以服务更多的用户。
 *  从工程的角度来说，缓存的引入并不是盲目的，如果数据库压力不大的情况，并不需要添加缓存。多添加一个数据中间件显然也会增加维护的成本，而且在实际使用过程中还会存在一些，例如`缓存穿透、缓存击穿、缓存雪崩、双写不一致`等问题。

**缓存类型**

*  缓存根据存储的方式可以分成`本地缓存和分布式缓存`。
 *  **本地缓存**：本地缓存一般指的是缓存在`应用进程内部的缓存`。以 Java 技术栈为例，可是自己实现一个 HashMap 作为数据缓存，也可以直接使用现成的缓存方案，例如`ehcache、caffeine`等。
 *  **分布式缓存**：缓存和应用环境分离，会单独存放在自己的服务器或集群里，且多个应用可直接的共享缓存。`常见的缓存方案有 MemCache 和 Redis 等。`

## 3.SpringCache介绍 ##

`Spring从3.1`开始定义了`org.springframework.cache.Cache`和`org.springframework.cache.CacheManager`接口来**统一不同的缓存技术**； 并支持使用`JCache（JSR-107）注解`简化我们开发。它本质上是一个`缓存抽象层`，底层是用`Map`实现的。`缓存数据量不是很大的时候推荐使用`，不然还是要用第三方的缓存redis、echcache等。

*  **Cache接口**：缓存抽象规范接口，定义实现缓存的基本操作（增加，删除，获取缓存，一般不会直接和此接口打交道）。具体实现各种xxxCache，比如有：`RedisCache、EhCacheCache、ConcurrentMapCache`等
 *  **CacheManager接口**： Spring 提供的各种缓存技术的抽象接口  
    ，负责各种Cache组件的生命周期，

## 4.Spring支持的CacheManager ##

Spring针对不同的缓存技术，实现了不同的 CacheManager ，**默认使用**`SimpleCacheConfiguration，即使用ConcurrentMapCacheManager`。

<table> 
 <thead> 
  <tr> 
   <th>CacheManager</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>SimpleCacheManager</td> 
   <td>使用简单的 Collection 来存储缓存，主要用于测试</td> 
  </tr> 
  <tr> 
   <td><strong>ConcurrentMapCacheManager</strong></td> 
   <td>使用 ConcurrentMap 来存储缓存（默认）</td> 
  </tr> 
  <tr> 
   <td>NoOpCacheManager</td> 
   <td>仅测试用途，不会实际缓存数据</td> 
  </tr> 
  <tr> 
   <td><strong>EhCacheCacheManager</strong></td> 
   <td>使用 EhCache 作为缓存技术</td> 
  </tr> 
  <tr> 
   <td>GuavaCacheManager</td> 
   <td>使用 Google Guava 的 GuavaCache 作为缓存技术</td> 
  </tr> 
  <tr> 
   <td>HazelcastCacheManager</td> 
   <td>使用 Hazelcast 作为缓存技术</td> 
  </tr> 
  <tr> 
   <td>JCacheCacheManager</td> 
   <td>支持 JCache(JSR-107) 标准的实现作为缓存技术，如 ApacheCommonsJCS</td> 
  </tr> 
  <tr> 
   <td><strong>RedisCacheManager</strong></td> 
   <td>使用 Redis 作为缓存技术</td> 
  </tr> 
 </tbody> 
</table>

**在使用以上任意一个实现的 CacheManager 的时候，`需要在spring容器中注册实现的CacheManager的Bean`:**

@Configuration
    public class EhCacheConfig() { 
    	//将EhCacheCacheManager加载到spring容器中管理
    	@Bean
    	public EhCacheCacheManager cacheManager(CacheManager cacheManager ){ 
        	return new  EhCacheCacheManager(cacheManager);
    	}
    }

> 注意，每种缓存技术都有很多的额外配置，但配置 cacheManager缓存管理器是一定要配置的。

## 5.SpringBoot的配置支持 ##

在 Spring 中使用缓存技术的关键是配置 CacheManager ，而 `SpringBoot 为我们配置了多个 CacheManager 的实现`。

它的自动配置放在`org.springframework.boot.autoconfigure.cache`中。  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aKp5aKp5YiG5aKp_size_20_color_FFFFFF_t_70_g_se_x_16 1]  
在不做任何配置的情况下，`SpringBoot默认使用的是 SimpleCacheConfiguration ，即使用 ConcurrentMapCacheManager`。SpringBoot 支持以前缀来配置缓存。SpringBoot 支持以`前缀`来配置缓存。例如：

spring.cache.type= # 可选 generic、ehcache、hazelcast、infinispan、jcache、redis、guava、simple、none
    spring.cache.cache-names= # 程序启动时创建的缓存名称
    spring.cache.ehcache.config= # ehcache 配置文件的地址
    spring.cache.hazelcast.config= # hazelcast配置文件的地址
    spring.cache.infinispan.config= # infinispan配置文件的地址
    spring.cache.jcache.config= # jcache配置文件的地址
    spring.cache.jcache.provider= # 当多个 jcache 实现在类路径的时候，指定 jcache 实现
    # 等等。。。

> 在 SpringBoot 环境下，使用缓存技术只需要在项目中导入相关缓存技术的依赖包，并在配置类中使用 @EnableCaching 开启缓存支持即可。

**支持的缓存技术**

*  caffeine：Caffeine 是一种高性能的缓存库，基于 Google Guava。
 *  couchbase：CouchBase是一款非关系型JSON文档数据库。
 *  generic：由泛型机制和 static 组合实现的泛型缓存机制。
 *  hazelcast：一个高度可扩展的数据分发和集群平台，可用于实现分布式数据存储、数据缓存。
 *  infinispan：分布式的集群缓存系统。
 *  jcache`(Ehcache3)`：JCache 作为缓存。它是 JSR107 规范中提到的缓存规范。
 *  none：没有缓存。
 *  redis：用 Redis 作为缓存
 *  simple：用内存作为缓存。
 *  ehCache`(Ehcache2)`: 是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate中默认的CacheProvider

# 二.声明式缓存注解 #

## 0.几个重要概念&缓存注解 ##

对于缓存使用，Spring的缓存提供了一组java注解:

*  @EnableCaching：启用SpringCache 的开关。必须开启才能使用SpringCache相关功能。
 *  @CacheConfig:设置类级别上共享的一些常见缓存设置。
 *  @Cacheable: 在方法执行前 Spring 先查看缓存中是否有数据，若有，则直接返回缓存数据；若无数据，调用方法将方法返回值放入缓存中
 *  @CachePut: 无论怎样，都会将方法的返回值放到缓存中。
 *  @CacheEvict: 将一条或多条数据从缓存中删除
 *  @Caching：可以通过 @Caching 注解组合多个注解策略在一个方法上

> @Cacheable、@CachePut、@CacheEvict 都有`value 属性`，指定的是要使用的`缓存名称`；key 属性指定的是`数据在缓存中存储的key`。
> 
>  *  keyGenerator：缓存数据时key生成策略
>  *  serialize ： 缓存数据时value序列化策略
>  *  key和keyGenerator也是互斥的，同时指定这两个参数会导致异常
>  *  cacheManager和cacheResolver参数是互斥的，同时指定这两个参数会导致异常。因为实现CacheManager会忽略自定义的CacheResolver。

## 1.@CacheConfig ##

**该注解是一个`类级别注解`，用于指定该类注解的`默认配置`（缓存名称cacheNames、key生成器keyGenerator、缓存管理器cacheManager、缓存处理器cacheResolver）。**

> 注：方法级别的注解会覆盖类注解

**源码：**

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface CacheConfig { 
    	//表示使用哪个缓存
    	String[] cacheNames() default { };
    	//设置该接口下所有缓存方法key的默认key生成器
    	String keyGenerator() default "";
    	//设置该接口下所有缓存方法key的默认缓存管理器
    	String cacheManager() default "";
    	//设置该接口下所有缓存方法key的默认缓存解析器
    	String cacheResolver() default "";
    }

**伪代码：**

@CacheConfig(cacheNames = "user")
    @Service
    public class UserServiceImpl implements UserService { }

## 2.@Cacheable ##

**一般用于查询操作，根据key查询缓存.**

1.  如果key不存在，查询db，并将结果更新到缓存中。
2.  如果key存在，直接查询缓存中的数据。

> 可以标注在一个方法或者类上。`方法级只针对该方法。类上则针对类内所有的方法`。对于一个支持缓存的方法，Spring会在其被调用后将其`返回值缓存起来`，以保证下次利用同样的参数来执行该方法时可以直接从缓存中获取结果，而不需要再次执行该方法。Spring在缓存方法的返回值时是以键值对进行缓存的，值就是方法的返回结果。

**源码：**

@Target({ ElementType.TYPE, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Inherited
    @Documented
    public @interface Cacheable { 
    	// CacheName属性也是`value属性`，定义@Cacheable注解时，必须使用该属性。即`指定缓存的名字`。使用默认`CacheManager属性`，以及使用`默认的key属性(SimpleKey对象包含所有的参数值)。`
    	@AliasFor("cacheNames")
    	String[] value() default { };
    	//和value注解差不多，二选一
    	String[] cacheNames() default { }; 
    	// 该次缓存的key ,支持SpEL
    	String key() default "";
    	//key的生成器。key/keyGenerator二选一使用,默认使用SimpleKeyGenerator，默认将参数值作为key，但是可能会导致key重复出现。,
    	String keyGenerator() default "";
    	//指定缓存管理器 一般使用默认
    	//对于使用多个缓存管理器的应用程序，可以设置cacheMananger用于选择哪种缓存管理器（redis，EhCache...），非必需，当有多个才需要指定。
    	String cacheManager() default ""; 
    	//或者指定获取解析器 一般使用默认
    	//指定使用哪个缓存管理器。需要通过实现org.springframework.cache.interceptor.CacheResolver接口来解析
    	String cacheResolver() default ""; 
    	//条件则缓存 使用的比较多 支持SpEL缓存的条件，可以为空，在 用方法之前之后都能判断
    	String condition() default ""; 
    	//条件符合则不缓存 使用的比较多 支持SpEL，该表达式只在方法执行之后判断，此时可以拿到返回值result进行判断。
    	String unless() default ""; 
    	//是否使用异步模式
    	boolean sync() default false; 
    }

**示例**

//查询数据库后 数据添加到缓存
    @Override
    @Cacheable(cacheNames = "cacheManager", key = "'USER:'+#id", unless = "#result == null")
    public User getUser(Integer id) { 
    	return repository.getUser(id);
    }

> **在业务逻辑层service层，在需要缓存数据的方法上加上`@Cacheable注解`，`cacheNames+key`成为该缓存值的key，通过`#获取方法上的参数`。`"方法的返回值" 成为缓存的value`** 。
> 
>  *  标记`@Cacheable注解`后会去查询缓存中是否存在，命中就直接返回；没有命中查询数据库返回并缓存到cache中。
>  *  `#参数名`可以从`方法参数中取值`；也可以`#p0、#p1取出第几个参数（下标从0开始）`；参数如果是一个`对象可以#object.属性名（SpEL表达式）取值`。
>  *  注：cacheNames是`spring4.2`版本新加的，以前版本用value

## 3.@CachePut ##

**@CachePut标注的方法在执行前`不会去检查缓存中是否存在`，而是每次都会执行该方法，并将执行结果以键值对的形式存入指定的缓存中。**

> **与@Cacheable的区别**：@Cacheable会在执行方法前检查cache是否存在，存在就直接返回cache中的值，否则执>行方法并把返回值写入cache; 而@CachePut不会去检查，每次都会执行方法并把返回值写入cache.

**源码**

@Target({ ElementType.TYPE, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Inherited
    @Documented
    public @interface CachePut { 
    	// CacheName属性也是`value属性`，定义@Cacheable注解时，必须使用该属性。即`指定缓存的名字`。使用默认`CacheManager属性`，以及使用`默认的key属性(SimpleKey对象包含所有的参数值)。`
    	@AliasFor("cacheNames")
    	String[] value() default { };
    	//和value注解差不多，二选一
    	String[] cacheNames() default { }; 
    	// 该次缓存的key ,支持SpEL
    	String key() default "";
    	//key的生成器。key/keyGenerator二选一使用，默认使用SimpleKeyGenerator，默认将参数值作为key，但是可能会导致key重复出现。,
    	String keyGenerator() default "";
    	//指定缓存管理器 一般使用默认
    	//对于使用多个缓存管理器的应用程序，可以设置cacheMananger用于选择哪种缓存管理器（redis，EhCache...），非必需，当有多个才需要指定。
    	String cacheManager() default ""; 
    	//或者指定获取解析器 一般使用默认
    	//指定使用哪个缓存管理器。需要通过实现org.springframework.cache.interceptor.CacheResolver接口来解析
    	String cacheResolver() default ""; 
    	//条件则缓存 使用的比较多 支持SpEL缓存的条件，可以为空，在 用方法之前之后都能判断
    	String condition() default ""; 
    	//条件符合则不缓存 使用的比较多 支持SpEL，该表达式只在方法执行之后判断，此时可以拿到返回值result进行判断。
    	String unless() default ""; 
    	//是否使用异步模式
    	boolean sync() default false; 
    }

**示例**

//修改数据后更新缓存
    @Override
    @CachePut(cacheNames = "cacheManager", key = "'USER:'+#updateUser.id", unless = "#result == null")
    public User updateUser(User updateUser) { 
       return repository.save(updateUser);
    }

## 4.@CacheEvict ##

**根据key删除缓存中的数据。allEntries=true表示删除缓存中的所有数据。**

**源码**

@Target({ ElementType.TYPE, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Inherited
    @Documented
    public @interface CacheEvict { 
    	// CacheName属性也是`value属性`，定义@Cacheable注解时，必须使用该属性。即`指定缓存的名字`。使用默认`CacheManager属性`，以及使用`默认的key属性(SimpleKey对象包含所有的参数值)。`
    	@AliasFor("cacheNames")
    	String[] value() default { };
    	//和value注解差不多，二选一
    	String[] cacheNames() default { }; 
    	// 该次缓存的key ,支持SpEL
    	String key() default "";
    	//key的生成器。key/keyGenerator二选一使用，默认使用SimpleKeyGenerator，默认将参数值作为key，但是可能会导致key重复出现。,
    	String keyGenerator() default "";
    	//指定缓存管理器 一般使用默认
    	//对于使用多个缓存管理器的应用程序，可以设置cacheMananger用于选择哪种缓存管理器（redis，EhCache...），非必需，当有多个才需要指定。
    	String cacheManager() default ""; 
    	//或者指定获取解析器 一般使用默认
    	//指定使用哪个缓存管理器。需要通过实现org.springframework.cache.interceptor.CacheResolver接口来解析
    	String cacheResolver() default ""; 
    	//条件则移除 使用的比较多 支持SpEL缓存的条件，可以为空，在 用方法之前之后都能判断
    	String condition() default ""; 
    	//是否清空所有缓存内容 默认为 false，如果指定为 true，则方法调用后将立即清空所有缓存
    	boolean allEntries() default false;
    	//是否在方法执行前就清空，默认为 false，如果指定 为 true，则在方法还没有执行的时候就清空缓存， 默认情况下，如果方法执行抛出异常，则不会清空 缓存
    	boolean beforeInvocation() default false;
    }

**示例**

//清除一条缓存，key为要清空的数据
    @Override
    @CacheEvict(cacheNames = "cacheManager", key = "'USER:'+#id")
    public void deleteUser(Integer id) { 
      repository.deleteById(id);
    }

> 方法上标注@CacheEvict注解，方法执行完成后会用cacheNames+key去缓存中匹配然后移除缓存

## 6.使用SpEL获取元数据 ##

SpringCache提供了与缓存相关的专用元数据，例如参数名称。下表描述了可用于上下文的项目，以便于key的生成和条件计算。

<table> 
 <thead> 
  <tr> 
   <th>名字</th> 
   <th>位置</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>methodName</td> 
   <td>root</td> 
   <td>当前被调用的方法名</td> 
   <td>#root.methodName</td> 
  </tr> 
  <tr> 
   <td>method</td> 
   <td>root</td> 
   <td>当前被调用的方法</td> 
   <td>#root.method.name</td> 
  </tr> 
  <tr> 
   <td>target</td> 
   <td>root</td> 
   <td>当前被调用的目标对象</td> 
   <td>#root.target</td> 
  </tr> 
  <tr> 
   <td>targetClass</td> 
   <td>root</td> 
   <td>当前被调用的目标对象类</td> 
   <td>#root.targetClass</td> 
  </tr> 
  <tr> 
   <td>args</td> 
   <td>root</td> 
   <td>当前被调用的方法的参数列表</td> 
   <td>#root.args[0]</td> 
  </tr> 
  <tr> 
   <td>caches</td> 
   <td>root</td> 
   <td>当前方法调用使用的缓存列表 （如@Cacheable(value={“cache1”, “cache2”})），则有两个cache。</td> 
   <td>#root.caches[0].name</td> 
  </tr> 
  <tr> 
   <td>参数名称</td> 
   <td>调用的方法</td> 
   <td>方法参数的名字. 可以直接 #参数名 ，也可以使用 #p0或#a0 的 形式，0代表参数的索引。</td> 
   <td>#a0、#p0</td> 
  </tr> 
  <tr> 
   <td>result</td> 
   <td>调用的方法</td> 
   <td>仅用在unless, 方法执行后的返回值(缓存)（仅当方法执行之后的判断有效，如 ‘unless’，’cachePut’的表达式 ’cacheEvict’的表达式 beforeInvocation=false）</td> 
   <td>#result</td> 
  </tr> 
 </tbody> 
</table>

## 5.@Caching ##

**该注解是个`组合注解`。我们需`要在一个方法上同时使用多个相同类型注解`（例如@CacheEvict或@CachePut）。因为Key或Key的表达式在不同的缓存间是不同的。@Caching允许嵌套多个@Cacheable，@CachePut和@CacheEvict注解来使用。**

例如：使用两个@CacheEvict注解

@Caching(evict = {  @CacheEvict("primary"), @CacheEvict(cacheNames="secondary", key="#p0") })
    public Book importBooks(String deposit, Date date){ //...}

## 6. 使用注意 ##

*  `缓存注解所在的方法不能在类中进行内部调用`。
 *  缓存一定要有`过期超时策略`，避免系统不堪重负。
 *  缓存的值如果是集合考虑`对集合的大小的限制，避免序列化/反序列化性能`。

## 7.高级redis客户端 ##

*  `Spring Boot 2.x中 使用lettuce作为默认redis客户端`。当然你也可以引入redisson客户端。这两种是`非阻塞反应式高级redis客户端`。建议放弃阻塞客户端jedis
 *  上面引入的`spring-boot-starter-data-redis` 就是默认使用**lettuce**

## 8.缓存key的设置 ##

SpringCache缓存的数据结构为**Key-Value对**。我们需要设计一个优雅的key

**1.默认的KeyGenerator如何获取参数值？**

*  **若注解上只是指定`cacheName属性`，SimpleKeyGenerator将`获取所有的参数值。组成SimpleKey对象`。**
 *  指定`cacheName和key属性`，并且key的属性支持SpEL表达式：
 *  基本形式
    
        @Cacheable(value="cacheName", key="#id")
        public ResultDTO method(int id);
 *  组合形式
    
        @Cacheable(value="cacheName", key="T(String).valueOf(#name).concat('-').concat(#password))
        public ResultDTO method(int name, String password);
 *  对象形式
    
        @Cacheable(value="cacheName", key="#user.id)
        public ResultDTO method(User user);

**2.默认的SimpleKeyGenerator的缺陷？**

*  SimpleGenerator只会将参数值封装为`SimpleKey对象`。然后作为Key，可能会导致`不同方法Key冲突`。
    
     *  我们虽然可以使用SpEL表达式获取类名、方法名，在进行拼接。但是`需要为每一个注解指定，太过于繁杂` ,因此可以自定义key生成器统一生成key名。

**3.自定义key生成器-KeyGenerator**

*  `注解上keyGenerator属性与key属性是不能共存的，二选一`

/** * 构建redisKey生成规则 */
        @Bean
        public KeyGenerator simpleKeyGenerator() { 
            return new KeyGenerator() { 
                /** * 构建redisKey规则 * @param target 目标类 * @param method 目标方法 * @param params 方法形参 * @return 类名.方法名[参数值] 例如:TestService.queryCache[1] */
                @Override
                public Object generate(Object target, Method method, Object... params) { 
                    StringBuilder stringBuilder = new StringBuilder();
                    stringBuilder.append(target.getClass().getSimpleName());
                    stringBuilder.append(".");
                    stringBuilder.append(method.getName());
                    stringBuilder.append("[");
                    for (Object obj : params) { 
                        stringBuilder.append(obj.toString());
                    }
                    stringBuilder.append("]");
                    return stringBuilder.toString();
                }
            };
        }

**使用**

@Cacheable(cacheNames = "user",keyGenerator = "simpleKeyGenerator")
        public User queryCache(String id) { 
            System.out.println("queryCache=>id" + id);
            return cacheMap.getOrDefault(id, null);
        }

## 9.同步缓存 ##

**sync=true的时候，多个线程尝试用相同的key去缓存拿数据的时候，会是一个同步的操作。即只有一个线程在处理当前方法时，`其他线程则被阻塞，直到改缓存操作结束为止`。**

@Cacheable(cacheNames="foos", sync=true) 
    public Foo executeExpensiveOperation(String id) { //xxxx}

## 10.条件缓存 ##

**1.condition**：方法可能不总适合缓存（例如：他可能取决于给你定的参数）。**通过缓存注解的`condition属性`设置条件**，该属性采用 **`SpEL表达式`**，**该表达式的值等于true或false。如果为true，则缓存该方法。否则的话，每次调用该方法**。

例如：仅当参数name的长度小于32时才缓存以下方法：

@Cacheable(cacheNames="book", condition="#name.length() < 32") 
    public Book findBook(String name)

**2.unless（如果不）**：也可以使用 **`unless属性`** 来决定是否将值添加到缓存中，该参数也采用 **`SpEl表达式`**，该表达式输出结果boolean类型。**与condition不同的是，unless表达式是`在调用方法后求值的`，并且当SpEL`返回false时，加入到缓存中`**

例如：仅当方法返回结果参数id的不小于1000时才缓存以下方法：

@Cacheable(cacheNames="books", key="#isbn.rawNumber",unless ="#result.id < 1000" )
        public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed) { 
            log.info("执行方法！");
            Book book = Book.builder().id(1101).bookName("java").build();
            return book;
        }

# 三.SpringBoot整合Redis做为缓存组件 #

## 1.引入依赖 ##

**pom.xml引入依赖，同时也可以按需引入你采用的缓存中间件客户端；比如 Ehcache、redis等。**

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>
    
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    
    
    
    <dependency>
       <groupId>com.alibaba</groupId>
       <artifactId>fastjson</artifactId>
       <version>1.2.78</version>
    </dependency>
    
    
    <dependency>
       <groupId>org.projectlombok</groupId>
       <artifactId>lombok</artifactId>
       <version>1.18.18</version>
    </dependency>
    
    
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>1.1.10</version>
    </dependency>

> 产生堆外内存溢出异常，OutOfDirectMemory
> 
> 1.  springBoot2.0以后使用lettuce作为操作redis的客户端，它使用netty进行网络通信
> 2.  lettuce的bug导致netty堆外内存溢出,netty如果没有指定堆外内存，默认使用-Xmx
> 3.  可以通过-Dio.netty.maxDirectMemory进行设置，不能使用-Dio.netty.maxDirectMemory只去调大堆外内存

## 2.配置数据源和redis ##

**application.yml配置数据源和redis**

# Tomcat
    server:
      tomcat:
        uri-encoding: UTF-8
      port: 8002
      servlet:
        context-path: /
    
    #spring
    spring:
      # 使用数据源
      datasource:
        type: com.alibaba.druid.pool.DruidDataSource
        # 数据源配置
        druid:
          driver-class-name: com.mysql.cj.jdbc.Driver
          url: jdbc:mysql://192.168.0.201:3306/cc_agent?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=UTC
          username: egos
          password: Egos@123456
          # 初始化大小，最小，最大
          initial-size: 5
          min-idle: 5
          max-active: 20
          # 配置获取连接等待超时的时间
          max-wait: 60000
          # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位毫秒
          time-between-eviction-runs-millis: 60000
          # 配置一个连接在池中最小生存时间
          min-evictable-idle-time-millis: 300000
          #心跳检测
          validation-query: SELECT 1
          test-while-idle: true
          test-on-borrow: false
          test-on-return: false
          # 打开 PSCache，并且指定每个连接上 PSCache 的大小
          pool-prepared-statements: true
          max-pool-prepared-statement-per-connection-size: 20
          # 配置监控统计拦截的 Filter，去掉后监控界面 SQL 无法统计，wall 用于防火墙
          filters: stat,wall,slf4j
          # 通过 connection-properties 属性打开 mergeSql 功能；慢 SQL 记录
          connection-properties: druid.stat.mergeSql\=true;druid.stat.slowSqlMillis\=5000
          # 配置 DruidStatFilter
          web-stat-filter:
            enabled: true
            url-pattern: /*
            exclusions: .js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*
          # 配置 DruidStatViewServlet
          stat-view-servlet:
            url-pattern: /druid/*
            # IP 白名单，没有配置或者为空，则允许所有访问
            allow: 127.0.0.1
            # IP 黑名单，若白名单也存在，则优先使用
            deny: 192.168.31.253
            # 禁用 HTML 中 Reset All 按钮
            reset-enable: false
            # 登录用户名/密码
            login-username: druid
            login-password: 123456
      #redis基本配置
      redis:
        host: 192.168.0.201
        database: 3
        port: 6585
        password: mts_Pj^123456
      #Cache缓存类型
      cache:
        type: redis

## 3.启动类开启SpringCache ##

**启动类上加上`@EnableCaching`，开启SpringCache缓存配置**

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

## 4.自定义缓存配置 ##

### 普通配置类 ###

@Configuration
    public class RedisCacheConfig { 
        /** * 构建缓存管理器 * @param redisConnectionFactory * @return */
        @Bean
        public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) { 
            return RedisCacheManager.builder()
                    .disableCreateOnMissingCache() //如果是空值，不缓存
                    //非阻塞的redis缓存写入器
                    .cacheWriter(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))
                    // 默认配置：设置默认超时策略，未配置的 key 会使用这个
                    .cacheDefaults(this.getRedisCacheConfigurationWithTtl(30))
                    // 对各种缓存空间进行个性化配置: 可以指定key超时策略
                    .withInitialCacheConfigurations(this.getRedisCacheConfigurationMap())
                    .build();
    
        }
    
        /** * 构建默认redisKey生成规则 * @return */
        @Bean
        public KeyGenerator simpleKeyGenerator() { 
            return new KeyGenerator() { 
                /** * 构建redisKey规则 * @param target 目标类 * @param method 目标方法 * @param params 方法形参 * @return 类名.方法名[参数值] 例如:TestService.queryCache[1] */
                @Override
                public Object generate(Object target, Method method, Object... params) { 
                    StringBuilder stringBuilder = new StringBuilder();
                    stringBuilder.append(target.getClass().getSimpleName());
                    stringBuilder.append(".");
                    stringBuilder.append(method.getName());
                    stringBuilder.append("[");
                    for (Object obj : params) { 
                        stringBuilder.append(obj.toString());
                    }
                    stringBuilder.append("]");
                    return stringBuilder.toString();
                }
            };
        }
    
        /** * 构建redis缓存默认超时配置 * @param seconds 单位(秒) * @return */
        private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) { 
            //获取redis默认配置
            return RedisCacheConfiguration.defaultCacheConfig()
                    //设置Cache的前缀，默认::
                    .computePrefixWith(cacheName -> cacheName + ":")
                    //若返回值为null，则不允许存储到Cache中
                    .disableCachingNullValues()
                    //设置缓存的key的序列化器
                    .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(this.genericKeySerializer()))
                    //设置缓存的value的序列化器
                    .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(this.jackson2JsonRedisValueSerializer()))
                    //设置缓存默认超时时间(单位秒)
                    .entryTtl(Duration.ofSeconds(seconds));
        }
    
        /** * 构建redis缓存指定key超时配置 * 要指定 key 的过期时间，只要在getRedisCacheConfigurationMap方法中添加就可以。然后只需要 @Cacheable 就可以把数据存入 redis * * @Cacheable(value = "UserInfoList", keyGenerator = "simpleKeyGenerator") // 60秒 * @Cacheable(value = "UserInfoListAnother", keyGenerator = "simpleKeyGenerator") // 120秒 * @Cacheable(value = "DefaultKeyTest", keyGenerator = "simpleKeyGenerator") // 30秒，未指定的key，使用默认策略 */
        private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap() { 
            //redisCacheConfigurationMap方法是一个以缓存名称为key，其对应的redis配置类为值得键值映射
            Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
            redisCacheConfigurationMap.put("UserInfoList", this.getRedisCacheConfigurationWithTtl(60));//30秒
            redisCacheConfigurationMap.put("UserInfoListAnother", this.getRedisCacheConfigurationWithTtl(160));//120秒
            return redisCacheConfigurationMap;
        }
    
    
        /** * 通用的的key序列化器 * * @return */
        private RedisSerializer<String> genericKeySerializer() { 
            return new StringRedisSerializer();
        }
    
        /** * 通用的value序列化器 * @return */
        private RedisSerializer<Object> genericValueSerializer() { 
            return new GenericJackson2JsonRedisSerializer();
        }
    
        /** * 定制化的value序列化器 * @return */
        private RedisSerializer<Object> jackson2JsonRedisValueSerializer() { 
            //redis缓存value序列化器
            Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
            jackson2JsonRedisSerializer.setObjectMapper(redisConfigurationObjectMapper());
            return jackson2JsonRedisSerializer;
        }
    
    
        /** * 注意不要将ObjectMapper加入到Spring容器中。因为Spring容器中存在一个ObjectMapper，以用于@RequestBody、ResponseBody、RestTemplate等地的序列化和反序列化。 * 为什么不采用Spring容器的ObjectMapper对象，而要自己设置? * 是因为Redis配置了objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);属性，在序列化时记录类/属性的类型，以便在反序列化时得到POJO对象 */
        private ObjectMapper redisConfigurationObjectMapper() { 
            ObjectMapper objectMapper = new ObjectMapper();
            objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    
            //JDK1.8新版时间格式化Model
            JavaTimeModule javaTimeModule = new JavaTimeModule();
            javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
            javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
            objectMapper.registerModule(javaTimeModule);
            //Date类型禁止转换为时间戳
            objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
            //序列化时格式化时间戳
            objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
            //字段名字开启驼峰命名法
            objectMapper.setPropertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE);
            //序列化无public的属性或方法时，不会抛出异常
            objectMapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
            //序列化时保存对象类型,以便反序列化时直接得到具体POJO
            objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
            //非空数据才进行格式化
            objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
            //针对BigDecimal，序列化时，不采取科学计数法
            objectMapper.enable(JsonGenerator.Feature.WRITE_BIGDECIMAL_AS_PLAIN);
            //反序列化时，POJO中不含有JSON串的属性，不解析该字段，并且不会抛出异常
            objectMapper.enable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
            //反序列化{}时，不抛出异常，而是得到null值
            objectMapper.enable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT);
            return objectMapper;
        }
    }

### 或者继承CachingConfigurerSupport类 ###

redis缓存配置类CacheConfig,这里对spring的缓存进行了配置，包括`KeyGenerator,CacheResolver,CacheErrorHandler,CacheManager,还有redis序列化方式`。

@Configuration
    public class RedisCacheConfig2 extends CachingConfigurerSupport { 
    
        @Resource
        private RedisConnectionFactory factory;
    
        /** * 构建默认redisKey生成规则 * * @return */
        @Bean
        public KeyGenerator simpleKeyGenerator() { 
            return new KeyGenerator() { 
                /** * 构建redisKey规则 * @param target 目标类 * @param method 目标方法 * @param params 方法形参 * @return 类名.方法名[参数值] 例如:TestService.queryCache[1] */
                @Override
                public Object generate(Object target, Method method, Object... params) { 
                    StringBuilder stringBuilder = new StringBuilder();
                    stringBuilder.append(target.getClass().getSimpleName());
                    stringBuilder.append(".");
                    stringBuilder.append(method.getName());
                    stringBuilder.append("[");
                    for (Object obj : params) { 
                        stringBuilder.append(obj.toString());
                    }
                    stringBuilder.append("]");
                    return stringBuilder.toString();
                }
            };
        }
    
        @Bean
        public RedisTemplate<Object, Object> redisTemplate() { 
            RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
            redisTemplate.setConnectionFactory(factory);
            GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
            redisTemplate.setKeySerializer(genericJackson2JsonRedisSerializer);
            redisTemplate.setValueSerializer(genericJackson2JsonRedisSerializer);
            redisTemplate.setHashKeySerializer(new StringRedisSerializer());
            redisTemplate.setHashValueSerializer(genericJackson2JsonRedisSerializer);
            return redisTemplate;
        }
    
        @Bean
        @Override
        public CacheResolver cacheResolver() { 
            return new SimpleCacheResolver(cacheManager(factory));
        }
    
        @Bean
        @Override
        public CacheErrorHandler errorHandler() { 
            // 用于捕获从Cache中进行CRUD时的异常的回调处理器。
            return new SimpleCacheErrorHandler();
        }
    
        /** * 构建缓存管理器 * * @param redisConnectionFactory * @return */
        @Bean
        public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) { 
            return RedisCacheManager.builder()
                    .disableCreateOnMissingCache() //如果是空值，不缓存
                    //非阻塞的redis缓存写入器
                    .cacheWriter(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))
                    // 默认配置：设置默认超时策略，未配置的 key 会使用这个
                    .cacheDefaults(this.getRedisCacheConfigurationWithTtl(30))
                    // 对各种缓存空间进行个性化配置: 可以指定key超时策略
                    .withInitialCacheConfigurations(this.getRedisCacheConfigurationMap())
                    .build();
    
        }
    
        /** * 构建redis缓存默认超时配置 * * @param seconds 单位(秒) * @return */
        private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) { 
            //获取redis默认配置
            return RedisCacheConfiguration.defaultCacheConfig()
                    //设置Cache的前缀，默认::
                    .computePrefixWith(cacheName -> cacheName + ":")
                    //若返回值为null，则不允许存储到Cache中
                    .disableCachingNullValues()
                    //设置缓存的key的序列化器
                    .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(this.genericKeySerializer()))
                    //设置缓存的value的序列化器
                    .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(this.jackson2JsonRedisValueSerializer()))
                    //设置缓存默认超时时间(单位秒)
                    .entryTtl(Duration.ofSeconds(seconds));
        }
    
        /** * 构建redis缓存指定key超时配置 * 要指定 key 的过期时间，只要在getRedisCacheConfigurationMap方法中添加就可以。然后只需要 @Cacheable 就可以把数据存入 redis * * @Cacheable(value = "UserInfoList", keyGenerator = "simpleKeyGenerator") // 60秒 * @Cacheable(value = "UserInfoListAnother", keyGenerator = "simpleKeyGenerator") // 120秒 * @Cacheable(value = "DefaultKeyTest", keyGenerator = "simpleKeyGenerator") // 30秒，未指定的key，使用默认策略 */
        private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap() { 
            //redisCacheConfigurationMap方法是一个以缓存名称为key，其对应的redis配置类为值得键值映射
            Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
            redisCacheConfigurationMap.put("UserInfoList", this.getRedisCacheConfigurationWithTtl(60));//30秒
            redisCacheConfigurationMap.put("UserInfoListAnother", this.getRedisCacheConfigurationWithTtl(160));//120秒
            return redisCacheConfigurationMap;
        }
    
        /** * 通用的的key序列化器 * * @return */
        private RedisSerializer<String> genericKeySerializer() { 
            return new StringRedisSerializer();
        }
    
        /** * 定制化的value序列化器 * * @return */
        private RedisSerializer<Object> jackson2JsonRedisValueSerializer() { 
            //redis缓存value序列化器
            Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
            jackson2JsonRedisSerializer.setObjectMapper(redisConfigurationObjectMapper());
            return jackson2JsonRedisSerializer;
        }
    
    
        /** * 注意不要将ObjectMapper加入到Spring容器中。因为Spring容器中存在一个ObjectMapper，以用于@RequestBody、ResponseBody、RestTemplate等地的序列化和反序列化。 * 为什么不采用Spring容器的ObjectMapper对象，而要自己设置? * 是因为Redis配置了objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);属性，在序列化时记录类/属性的类型，以便在反序列化时得到POJO对象 */
        private ObjectMapper redisConfigurationObjectMapper() { 
            ObjectMapper objectMapper = new ObjectMapper();
            objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    
            //JDK1.8新版时间格式化Model
            JavaTimeModule javaTimeModule = new JavaTimeModule();
            javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
            javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
            objectMapper.registerModule(javaTimeModule);
            //Date类型禁止转换为时间戳
            objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
            //序列化时格式化时间戳
            objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
            //字段名字开启驼峰命名法
            objectMapper.setPropertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE);
            //序列化无public的属性或方法时，不会抛出异常
            objectMapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
            //序列化时保存对象类型,以便反序列化时直接得到具体POJO
            objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
            //非空数据才进行格式化
            objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
            //针对BigDecimal，序列化时，不采取科学计数法
            objectMapper.enable(JsonGenerator.Feature.WRITE_BIGDECIMAL_AS_PLAIN);
            //反序列化时，POJO中不含有JSON串的属性，不解析该字段，并且不会抛出异常
            objectMapper.enable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
            //反序列化{}时，不抛出异常，而是得到null值
            objectMapper.enable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT);
            return objectMapper;
        }
    }

## 5.编写缓存处理类 ##

**1. 缓存实体类**

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class User { 
        private String id;
        private String username;
        private String password;
    }

**2. 在业务逻辑层service(`推荐`)中使用Cache缓存注解**

@Service
    @CacheConfig(cacheNames = { "UserCache"})
    public class TestService { 
        public static Map<String, User> cacheMap = null;
        static { 
            cacheMap = new HashMap<>();
            cacheMap.put("1", new User("1", "admin", "11111"));
            cacheMap.put("2", new User("2", "liuer", "22222"));
            cacheMap.put("3", new User("3", "zhangsan", "333333"));
            cacheMap.put("4", new User("4", "lisi", "444444"));
            cacheMap.put("5", new User("5", "wangwu", "555555"));
        }
    
        /** * 查单个(带缓存) *@Cacheable：使用cacheNames+key成为该缓存值的key，通过#获取方法上的参数。方法的返回值成为缓存的value。 * 首先会去查询缓存中是否存在，命中就直接返回；没有命中查询数据库返回并缓存到cache中 * keyGenerator = "simpleKeyGenerator":表示使用key生成器simpleKeyGenerator */
        @Cacheable(cacheNames = "user",keyGenerator = "simpleKeyGenerator")
        public User queryCache(String id) { 
            System.out.println("queryCache=>id" + id);
            return cacheMap.getOrDefault(id, null);
        }
    
        /** * 测试key是否可以任意拼接 * * @Cacheable(cacheNames = "UserInfoListAnother", key = "'id:'+#id") * cacheNames = "UserInfoListAnother"表示 使用UserInfoListAnother的缓存策略,key超时时间为120秒 * key = "'id:'+#id" 表示生成的key为 UserInfoListAnother::id:49 */
         @Cacheable(cacheNames = "UserInfoListAnother", key = "'id:'+#id")
        public User queryCache2(String id) { 
            System.out.println("queryCache2=>id" + id);
            return cacheMap.getOrDefault(id, null);
        }   
        
        /** * 查所有(带缓存) */
        @Cacheable(cacheNames = "userAll")
        public  List<User> queryCacheAll() { 
            System.out.println("queryCache=>queryAll");
    
            List<User> userList = new ArrayList<>();
            cacheMap.forEach((k, v) -> { 
                userList.add(v);
            });
            return userList;
        }
    
        /** * 移除元素和缓存 * @CacheEvict注解：法执行完成后会用cacheNames+key去缓存中匹配然后移除缓存 */
        @CacheEvict(cacheNames = "user", key = "#id")
        public User removeCache(String id) { 
            System.out.println("removeCache=>id" + id);
            return cacheMap.remove(id);
        }
    
        /** * 强制更新元素缓存 * @CachePut注解，也会把返回值写入到缓存中去。 * 与@Cacheable的区别：@Cacheable会在执行方法前检查cache是否存在，存在就直接返回cache中的值，否则执行方法并把返回值写入cache; 而@CachePut不会去检查，每次都会执行方法并把返回值写入cache */
        @CachePut(cacheNames = "user", key = "#user.id")
        public User updateCache(User user) { 
            System.out.println("updateCache=>id" + user.getId());
    
            if (!cacheMap.containsKey(user.getId())) { 
                return null;
            }
    
            User updateUser = cacheMap.get(user.getId());
            updateUser.setUsername(user.getUsername());
            updateUser.setPassword(user.getPassword());
            return updateUser;
        }
    }

**3.在controller编写接口**

@RestController
    @RequestMapping("/test")
    @Slf4j
    public class TestController { 
        @Autowired
        private TestService userService;
        
        //统一返回体
        private String success(Object data) { 
            JSONObject result = new JSONObject();
            result.put("code", "1");
            result.put("data", data);
            result.put("msg", "调用成功");
            return result.toJSONString();
        }
    
        //查询单个,使用指定的key生成器
        @GetMapping("/queryCache")
        Callable<String> queryCache(String id) { 
            return () -> success(userService.queryCache(id));
        }
    
        //查询单个,使用指定的key缓存策略
        @GetMapping("/queryCache2")
        Callable<String> queryCache2(String id) { 
            return () -> success(userService.queryCache2(id));
        }
    
        //查询所有
        @GetMapping("/queryAllCache")
        Callable<String> queryCacheAll(String id) { 
            return () -> success(userService.queryCacheAll());
        }
    
        //移除
        @GetMapping("/removeCache")
        Callable<String> removeCache(String id) { 
            return () -> success(userService.removeCache(id));
        }
        
        //更新元素
        @GetMapping("/updateCache")
        Callable<String> updateCache(User user) { 
            return () -> success(userService.updateCache(user));
        }
    }

# 四.SpringBoot整合EhCache3做缓存组件 #

`EhCache`是一个比较成熟的`Java缓存框架`，最早从`hibernate`发展而来， 是`进程中的缓存系统`，它提供了用`内存，磁盘文件存储`，以及`分布式存储方式`等多种灵活的cache管理方案，快速简单。

**Ehcache3支持`堆、堆外、磁盘以及集群缓存`；但是除了堆之外的3种缓存，`缓存的对象对必须支持序列化和反序列化`。我们在使用的时候，可以单独使用任意一个**

*  **heap**：`堆缓存`，**受到jvm的管控，可以不序列化，速度最快**；`默认使用的是引用传递`，也可以使用复制器来进行值传递。`可以设置缓存条数或者缓存的大小来进行堆缓存大小的设置`。尽量不要设置的过大，否则容易引起GC.(如果设置缓存的大小，则计算比较麻烦，同时又多了一个计算缓存大小的过程)。
 *  **off-heap**：`堆外缓存`，**不受jvm的管控，受到RAM的限制，在ehcache中配置，至少1M**。通过`-XX:MaxDirectMemorySize`限制ehcache可分配的`最大堆外内存`，但是实际使用发现，不配置也能使用。如果不配置，使用堆外缓存时，ehcache将会使用jvm的内存，最大值为堆内存，但实际比-Xmx要小，可以通过Runtime,getRuntime().maxMemory()获取。因此，对于堆内对垃圾收集的影响过于严重的大量数据，应该选择堆外。
 *  **disk**：`磁盘存储`，**尽量使用高性能的SSD**。这一层的存储，不能在不同的CacheManager之间共享！
 *  **clustered**：`群集存储`\-该数据存储是远程服务器上的缓存
 *  [ehcache2 和 ehcache3的配置详解][ehcache2 _ ehcache3]

## 1.引入依赖 ##

**pom.xml引入依赖，同时也可以按需引入你采用的缓存中间件客户端；比如 Ehcache、redis等。**

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>
    
    
    
    
     
    <dependency>
        <groupId>org.ehcache</groupId>
        <artifactId>ehcache</artifactId>
    </dependency>
    
    <dependency>
        <groupId>javax.cache</groupId>
        <artifactId>cache-api</artifactId>
    </dependency>
    
    
    <dependency>
       <groupId>com.alibaba</groupId>
       <artifactId>fastjson</artifactId>
       <version>1.2.78</version>
    </dependency>
    
    
    <dependency>
       <groupId>org.projectlombok</groupId>
       <artifactId>lombok</artifactId>
       <version>1.18.18</version>
    </dependency>
    
    
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>1.1.10</version>
    </dependency>

## 2.创建ehcache3的配置文件ehcache.xml ##

*  位置：`classpath`目录下，即`src/main/resources/ehcache.xml`  
    ![在这里插入图片描述][207214d420f7470e928d76cf4584971c.png]

**ehcache2的配置文件，需要引入`net.sf.ehcache`**

<?xml version="1.0" encoding="UTF-8"?>
    <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd" updateCheck="false">
    
        
        
        <diskStore path="java.io.tmpdir/Tmp_EhCache" />
    
        
        <defaultCache eternal="false" maxElementsInMemory="1000" overflowToDisk="false" diskPersistent="false" timeToIdleSeconds="300" timeToLiveSeconds="0" memoryStoreEvictionPolicy="LRU" />
    
        
        
        <cache name="user" eternal="false" maxElementsInMemory="1000" overflowToDisk="false" diskPersistent="false" timeToIdleSeconds="30" timeToLiveSeconds="0" memoryStoreEvictionPolicy="LRU" />
        <cache name="userAll" eternal="false" maxElementsInMemory="1000" overflowToDisk="false" diskPersistent="false" timeToIdleSeconds="60" timeToLiveSeconds="0" memoryStoreEvictionPolicy="LRU" />
        
        
        
        
        
        
        
        
       
       
        
        
        	
        	
        	
    </ehcache>

**ehcach3的配置文件，需要引入`org.ehcache`**

## 3. 在application.yml中加入以下配置代码 ##

**application.yml指定`缓存组件的类型ehcache`以及`ehcache.xml位置`**

# Tomcat
    server:
      tomcat:
        uri-encoding: UTF-8
      port: 8002
      servlet:
        context-path: /
    
    #spring
    spring:
      # 使用数据源
      datasource:
        type: com.alibaba.druid.pool.DruidDataSource
        # 数据源配置
        druid:
          driver-class-name: com.mysql.cj.jdbc.Driver
          url: jdbc:mysql://192.168.0.201:3306/cc_agent?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=UTC
          username: egos
          password: Egos@123456
          # 初始化大小，最小，最大
          initial-size: 5
          min-idle: 5
          max-active: 20
          # 配置获取连接等待超时的时间
          max-wait: 60000
          # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位毫秒
          time-between-eviction-runs-millis: 60000
          # 配置一个连接在池中最小生存时间
          min-evictable-idle-time-millis: 300000
          #心跳检测
          validation-query: SELECT 1
          test-while-idle: true
          test-on-borrow: false
          test-on-return: false
          # 打开 PSCache，并且指定每个连接上 PSCache 的大小
          pool-prepared-statements: true
          max-pool-prepared-statement-per-connection-size: 20
          # 配置监控统计拦截的 Filter，去掉后监控界面 SQL 无法统计，wall 用于防火墙
          filters: stat,wall,slf4j
          # 通过 connection-properties 属性打开 mergeSql 功能；慢 SQL 记录
          connection-properties: druid.stat.mergeSql\=true;druid.stat.slowSqlMillis\=5000
          # 配置 DruidStatFilter
          web-stat-filter:
            enabled: true
            url-pattern: /*
            exclusions: .js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*
          # 配置 DruidStatViewServlet
          stat-view-servlet:
            url-pattern: /druid/*
            # IP 白名单，没有配置或者为空，则允许所有访问
            allow: 127.0.0.1
            # IP 黑名单，若白名单也存在，则优先使用
            deny: 192.168.31.253
            # 禁用 HTML 中 Reset All 按钮
            reset-enable: false
            # 登录用户名/密码
            login-username: druid
            login-password: 123456
      #缓存配置
      cache:
        #使用 jcache（Ehcache3）/ ehcache（Ehcache2） 作为缓存组件
        type: jcache
        jcache:
          config: classpath:ehcache.xml

## 4.启动类开启SpringCache(同引入Redis代码) ##

## 5.编写缓存处理类(同引入Redis代码) ##

注意： **`由于实体类需要支持的磁盘存储，所以需要实体类实现可序列化接口Serializable`**

# 五.SpringBoot整合Caffeine做缓存组件 #

## 1.引入依赖 ##

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>
    
    
    <dependency>
       <groupId>com.github.ben-manes.caffeine</groupId>
       <artifactId>caffeine</artifactId>
     </dependency>
     
    
    <dependency>
       <groupId>com.alibaba</groupId>
       <artifactId>fastjson</artifactId>
       <version>1.2.78</version>
    </dependency>
    
    
    <dependency>
       <groupId>org.projectlombok</groupId>
       <artifactId>lombok</artifactId>
       <version>1.18.18</version>
    </dependency>
    
    
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>1.1.10</version>
    </dependency>

## 2. 在application.yml中加入以下配置代码 ##

**application.yml指定`缓存组件的类型ehcache`以及`ehcache.xml位置`**

# Tomcat
    server:
      tomcat:
        uri-encoding: UTF-8
      port: 8002
      servlet:
        context-path: /
    
    #spring
    spring:
      # 使用数据源
      datasource:
        type: com.alibaba.druid.pool.DruidDataSource
        # 数据源配置
        druid:
          driver-class-name: com.mysql.cj.jdbc.Driver
          url: jdbc:mysql://192.168.0.201:3306/cc_agent?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=UTC
          username: egos
          password: Egos@123456
          # 初始化大小，最小，最大
          initial-size: 5
          min-idle: 5
          max-active: 20
          # 配置获取连接等待超时的时间
          max-wait: 60000
          # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位毫秒
          time-between-eviction-runs-millis: 60000
          # 配置一个连接在池中最小生存时间
          min-evictable-idle-time-millis: 300000
          #心跳检测
          validation-query: SELECT 1
          test-while-idle: true
          test-on-borrow: false
          test-on-return: false
          # 打开 PSCache，并且指定每个连接上 PSCache 的大小
          pool-prepared-statements: true
          max-pool-prepared-statement-per-connection-size: 20
          # 配置监控统计拦截的 Filter，去掉后监控界面 SQL 无法统计，wall 用于防火墙
          filters: stat,wall,slf4j
          # 通过 connection-properties 属性打开 mergeSql 功能；慢 SQL 记录
          connection-properties: druid.stat.mergeSql\=true;druid.stat.slowSqlMillis\=5000
          # 配置 DruidStatFilter
          web-stat-filter:
            enabled: true
            url-pattern: /*
            exclusions: .js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*
          # 配置 DruidStatViewServlet
          stat-view-servlet:
            url-pattern: /druid/*
            # IP 白名单，没有配置或者为空，则允许所有访问
            allow: 127.0.0.1
            # IP 黑名单，若白名单也存在，则优先使用
            deny: 192.168.31.253
            # 禁用 HTML 中 Reset All 按钮
            reset-enable: false
            # 登录用户名/密码
            login-username: druid
            login-password: 123456
      #缓存配置
      cache:
        #使用 caffeine 作为缓存组件
        type: caffeine
      #缓存配置
      cache:
        #使用 caffeine 作为缓存组件
        type: caffeine
        caffeine:
          # initialCapacity：缓存初始容量
          # maximumSize：配置缓存的最大容量，当快要达到容量上限的时候，缓存管理器会根据一定的策略将部分缓存项移除。
          # expireAfterAccess： 配置缓存项的过期机制，如代码所示当缓存项被访问后30秒将会过期，从而被移除。
          # refreshAfterWrite 创建缓存或者最近一次更新缓存后经过固定的时间间隔，刷新缓存，使用refreshAfterWrite必须要设置cacheLoader
          spec: initialCapacity=50,maximumSize=500,expireAfterWrite=10s,refreshAfterWrite=5s

**Caffeine配置说明**

*  initialCapacity=\[integer\]: 初始的缓存空间大小
 *  maximumSize=\[long\]: 缓存的最大条数，`maximumSize和maximumWeight不可以同时使用`
 *  maximumWeight=\[long\]: 缓存的最大权重，`maximumSize和maximumWeight不可以同时使用`
 *  expireAfterAccess=\[duration\]: 最后一次写入或访问后经过固定时间过期(最后一次访问了之后多久过期）。`expireAfterWrite和expireAfterAccess同时存在时，以expireAfterWrite为准`。)
 *  expireAfterWrite=\[duration\]: 最后一次写入后经过固定时间过期(写了之后多久过期)
 *  expireAfter(Expiry): 自定义策略，过期时间由Expiry实现独自计算。
    
    > 在expireAfter中需要自己`实现Expiry接口`，这个接口支持`create,update,以及access了之后多久过期`。注意这个API和`前面两个API是互斥`的。这里和前面两个API不同的是，需要你告诉缓存框架，他应该在具体的某个时间过期，也就是通过前面的重写create,update,以及access的方法，获取具体的过期时间。
 *  refreshAfterWrite=\[duration\]: 创建缓存或者最近一次更新缓存后经过固定的时间间隔，刷新缓存
 *  weakKeys: 打开key的弱引用，`weakValues和softValues不可以同时使用`
 *  weakValues：打开value的弱引用
 *  softValues：打开value的软引用
 *  recordStats：开发统计功能

> **CacheLoader是cache的一种加载策略，key不存在或者key过期之类的都可以通过CacheLoader来自定义获得/重新获得数据。`使用refreshAfterWrite必须要设置cacheLoader`**
> 
>  *  CacheLoader实质是一个监听，除上面的load与reload事件外还包含，`expireAfterCreate，expireAfterUpdate，expireAfterRead`等可以很灵活的配置CacheLoader，具体详细配置可查看这里 https://www.jianshu.com/p/15d0a9ce37dd，详细原理查看：https://www.cnblogs.com/liujinhua306/p/9808500.html  
>     **还可以通过bean配置Caffeine,需要注意的是使用bean配置的方式`spring.cache.caffeine.spec`就不能指定了**

@Configuration
    public class CaffeineCacheConfig { 
        private static List<String> getNames() { 
            List<String> names = new ArrayList<>(2);
            names.add("user");
            names.add("userAll");
            return names;
        }
    
        @Bean
        @Primary
        public CacheManager cacheManagerWithCaffeine() { 
            CaffeineCacheManager cacheManager = new CaffeineCacheManager();
    
            Caffeine caffeine = Caffeine.newBuilder()
                    //cache的初始容量值
                    .initialCapacity(100)
                    //maximumSize用来控制cache的最大缓存数量，maximumSize和maximumWeight不可以同时使用，
                    .maximumSize(1000)
    
                    //控制最大权重,，maximumSize和maximumWeight不可以同时使用，
                    //.maximumWeight(100)
    
                    //创建缓存或者最近一次更新缓存后经过固定的时间间隔，刷新缓存,使用refreshAfterWrite必须要设置cacheLoader
                    //.refreshAfterWrite(5, TimeUnit.SECONDS)
    
                    //最后一次写入后经过固定时间过期(写了之后多久过期)
                    .expireAfterWrite(30, TimeUnit.SECONDS);
    
            /*.expireAfter(new Expiry<Object, Object>() { *//**
             * 创建缓存后过期
             * @param key 缓存key
             * @param value 缓存value
             * @param currentTime 缓存的当前时间
             * @return
             *//*
                        @Override
                        public long expireAfterCreate(Object key, Object value, long currentTime) { 
                            return  currentTime;
                        }
                        *//**
             * 更新缓存后过期
             * @param key 缓存key
             * @param value 缓存value
             * @param currentTime 缓存的当前时间
             * @param currentDuration 缓存的当前时间
             * @return
             *//*
                        @Override
                        public long expireAfterUpdate(Object key, Object value, long currentTime, long currentDuration) { 
                            return currentDuration;
                        }
    
                        *//**
             * 读取缓存后过期
             * @param key 缓存key
             * @param value 缓存value
             * @param currentTime 缓存的当前时间
             * @param currentDuration 缓存的当前时间
             * @return
             *//*
                        @Override
                        public long expireAfterRead(Object key, Object value, long currentTime, long currentDuration) { 
                            return currentDuration;
                        }
                    });*/
    
    
            cacheManager.setCaffeine(caffeine);
            //缓存加载策略
            //cacheManager.setCacheLoader(cacheLoader());
            //缓存名称列表
            cacheManager.setCacheNames(getNames());
            //是否允许缓存空值
            //cacheManager.setAllowNullValues(false);
            return cacheManager;
        }
    
        /** * 缓存加载策略 * * @return */
        @Bean
        public CacheLoader<Object, Object> cacheLoader() { 
            return new CacheLoader<Object, Object>() { 
                /** * 缓存加载的回调函数 * @param key 缓存key * @return * @throws Exception */
                @Override
                public Object load(Object key) throws Exception { 
                    return null;
                }
    
                /** * 达到配置文件中的refreshAfterWrite所指定的时间的回调函数 * @param key * @param oldValue * @return * @throws Exception */
                //
                @Override
                public Object reload(Object key, Object oldValue) throws Exception { 
                    //可以在这里处理重新加载策略，本例子，没有处理重新加载，只是返回旧值。
                    return oldValue;
                }
            };
        }
    }

## 3. 启动类开启SpringCache(同引入Redis代码) ##

## 4. 编写缓存处理类(同引入Redis代码) ##

*  [Caffeine缓存的简单介绍][Caffeine]

# 六.SpingCache缺点 #

**读取数据**

1.  缓存穿透，查询一个null值
    
    > **解决**：缓存空数据，properties文件中：spring.cache.redis.cache-null-values=true即可
2.  缓存击穿，大量并发进来同时查询一个正好过期的数据 。
    
    > **解决**：加锁大量并发只让一个去查，其他人等待，查到以后释放锁，其他人获取到锁，先查缓存，就会有数据，不用去db查询
3.  缓存雪崩：指在我们设置缓存时key采用了相同的过期时间，导致缓存在某一时刻同时失效，请求全部转发到DB，DB瞬时压力过重雪崩
    
    > **解决**：原有的失效时间基础上增加一个随机值，比如1-5分钟随机，这样每一个缓存的过期时间的重复率就会降低，就很难引发集体失效的事件。如在properties文件配置 spring.cache.redis.time-to-live=3600000

**写入数据**

1.  读写加锁
2.  引入Cannal,感知到MySQL的更新去更新数据库
3.  读多写多，直接去数据库查询

**总结：**

*  常规数据，(读多写少，及时性，一致性要求不高的数据)：完全可以使用spring-Cache解决:写模式
 *  特殊数据：特殊设计

# 七.SpingCache源码解析(后续补充) #

可以先看看下面的文章

[SpringBoot2.x—SpringCache（3） CacheManager源码][SpringBoot2.x_SpringCache_3_ CacheManager]

[ Spring Cache，从入门到真香-源码解析][Spring Cache_-]

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aKp5aKp5YiG5aKp_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/1ee7a24b032b4e9696abc339005c8128.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aKp5aKp5YiG5aKp_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220829/744448bdde0c404cad24967e6c91dcab.png
[ehcache2 _ ehcache3]: https://www.cnblogs.com/KylinBlog/p/14178853.html
[207214d420f7470e928d76cf4584971c.png]: /images/20220829/c977e45ddfab431e9e65fe796c235e43.png
[Caffeine]: https://www.cnblogs.com/eyougo/p/15032900.html
[SpringBoot2.x_SpringCache_3_ CacheManager]: https://www.jianshu.com/p/ef8fb285ed72
[Spring Cache_-]: https://yasinshaw.com/articles/111