SpringBoot——(九)SpringBoot与缓存

一、JSR107

Java Caching定义了5个核心接口，分别是CachingProvider, CacheManager, Cache, Entry和Expiry;

• CachingProvider:定义了创建、配置、获取、管理和控制多个CacheManager。一个应用可以在运行期访问多个CachingProvider。

• CacheManager:定义了创建、配置、获取、管理和控制多个唯一命名的Cache，这些Cache存在于CacheManager的上下文中。一个CacheManager仅被一个CachingProvider所拥有。

• Cache: 是一个类似Map的数据结构并临时存储以Key为索引的值。一个Cache仅被一个CacheManager所拥有。

• Entry:是一个存储在Cache中的key-value对。

• Expiry:每一个存储在Cache中的条目有一个定义的有效期。一旦超过这个时间，条目为过期的状态。一旦过期，条目将不可访问、更新和删除。缓存有效期可以通过ExpiryPolicy设置。

如果项目需要使用JSR107，需要导入一下包：

<dependency>
    <groupId>javax.cache</groupId>
    <artifactId>cache-api</artifactId>
</dependency>

二、Spring 对缓存的支持

2.1 Spring缓存抽象

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

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

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

下表是Spring提供的几个重要的注解和概念：

简要说明：

• @Cacheable注解加载方法中，那么该方法第一次会查询数据库，然后就会吧数据放在缓存中，使用Cache 进行数据的读取等操作。
• @CacheEvict删除缓存，例如根据id删除用户，那么也要删除缓存中的用户信息
• @CachePut更新缓存，例如更新用户信息后，同时也要更新缓存中的用户信息

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

2.4 SpEL获取上下文数据

例子：

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

@Cacheable(key = "targetClass + methodName +#p0")(解释：缓存的key为：当前被调用的目标对象的类+当前被调用的方法名+方法的第一个参数)

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

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

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

2.5 SpEL提供了多种运算符

三、SpringBoot缓存工作原理

3.1. SpringBoot提供的缓存自动配置类：org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration

@Configuration
@ConditionalOnClass({CacheManager.class})
@ConditionalOnBean({CacheAspectSupport.class})
@ConditionalOnMissingBean(
    value = {CacheManager.class},
    name = {"cacheResolver"}
)
@EnableConfigurationProperties({CacheProperties.class})
@AutoConfigureAfter({CouchbaseAutoConfiguration.class, HazelcastAutoConfiguration.class, HibernateJpaAutoConfiguration.class, RedisAutoConfiguration.class})
@Import({CacheAutoConfiguration.CacheConfigurationImportSelector.class})//导入缓存配置类
public class CacheAutoConfiguration {

3.2. CacheConfigurationImportSelector导入缓存配置类：

static class CacheConfigurationImportSelector implements ImportSelector {
        CacheConfigurationImportSelector() {
        }

        public String[] selectImports(AnnotationMetadata importingClassMetadata) {
            CacheType[] types = CacheType.values();
            String[] imports = new String[types.length];

            for(int i = 0; i < types.length; ++i) {
                imports[i] = CacheConfigurations.getConfigurationClass(types[i]);
            }

            return imports;
        }
    }

3.3. 那么导入了哪些配置类呢？


在CacheConfigurationImportSelector类中的selectImports方法中打断点，通过debug启动，发现导入的缓存配置类有：

• org.springframework.boot.autoconfigure.cache.GenericCacheConfiguration
• org.springframework.boot.autoconfigure.cache.JCacheCacheConfiguration
• org.springframework.boot.autoconfigure.cache.EhCacheCacheConfiguration
• org.springframework.boot.autoconfigure.cache.HazelcastCacheConfiguration
• org.springframework.boot.autoconfigure.cache.InfinispanCacheConfiguration
• org.springframework.boot.autoconfigure.cache.CouchbaseCacheConfiguration
• org.springframework.boot.autoconfigure.cache.RedisCacheConfiguration
• org.springframework.boot.autoconfigure.cache.CaffeineCacheConfiguration
• org.springframework.boot.autoconfigure.cache.GuavaCacheConfiguration
• org.springframework.boot.autoconfigure.cache.SimpleCacheConfiguration【默认】
• org.springframework.boot.autoconfigure.cache.NoOpCacheConfiguration

注意：上面列出来的配置类加载到Spring容器中都是有先后顺序的，默认顺序是从上之下。因此，如果你引用redis的stater后，容器中会默认使用redisCachConfigure配置类。

在application.properties中设置debug=true启动，通过日志可以发现，默认使用的缓存配置类为：org.springframework.boot.autoconfigure.cache.SimpleCacheConfiguration

@Configuration
@ConditionalOnMissingBean({CacheManager.class})
@Conditional({CacheCondition.class})
class SimpleCacheConfiguration {
    private final CacheProperties cacheProperties;
    private final CacheManagerCustomizers customizerInvoker;

    SimpleCacheConfiguration(CacheProperties cacheProperties, CacheManagerCustomizers customizerInvoker) {
        this.cacheProperties = cacheProperties;
        this.customizerInvoker = customizerInvoker;
    }

    @Bean
    public ConcurrentMapCacheManager cacheManager() {
        ConcurrentMapCacheManager cacheManager = new ConcurrentMapCacheManager();
        List<String> cacheNames = this.cacheProperties.getCacheNames();
        if (!cacheNames.isEmpty()) {
            cacheManager.setCacheNames(cacheNames);
        }

        return (ConcurrentMapCacheManager)this.customizerInvoker.customize(cacheManager);
    }
}

3.4. org.springframework.boot.autoconfigure.cache.SimpleCacheConfiguration配置类可以发现：

该配置类生效条件：1. 容器中没有CacheManager对象。并且该配置类给容器中注册了一个ConcurrentMapCacheManager对象。

3.5.ConcurrentMapCacheManager的作用：

public class ConcurrentMapCacheManager implements CacheManager, BeanClassLoaderAware {
    /**
	 * Return the cache associated with the given name.
	 * @param name the cache identifier (must not be {@code null})
	 * @return the associated cache, or {@code null} if none found
	 */
    @Override
	@Nullable
	public Cache getCache(String name) {
		Cache cache = this.cacheMap.get(name);
		if (cache == null && this.dynamic) {
			synchronized (this.cacheMap) {
				cache = this.cacheMap.get(name);
				if (cache == null) {
					cache = createConcurrentMapCache(name);
					this.cacheMap.put(name, cache);
				}
			}
		}
		return cache;
	}
	
    /**
	 * Create a new ConcurrentMapCache instance for the specified cache name.
	 * @param name the name of the cache
	 * @return the ConcurrentMapCache (or a decorator thereof)
	 */
	protected Cache createConcurrentMapCache(String name) {
		SerializationDelegate actualSerialization = (isStoreByValue() ? this.serialization : null);
		return new ConcurrentMapCache(name, new ConcurrentHashMap<>(256),
				isAllowNullValues(), actualSerialization);

	}
}

创建的Cache对象为ConcurrentMapCache类型；

总结：

SpringBoot环境中缓存自动配置类为：org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration

默认缓存配置类为：org.springframework.boot.autoconfigure.cache.SimpleCacheConfiguration

默认缓存管理器类型为：ConcurrentMapCacheManager

默认缓存类型为：ConcurrentMapCache

四、@Cacheable缓存运行流程

• 1、方法运行之前，先去查询Cache（缓存组件），按照cacheNames指定的名字获取；
  （CacheManager先获取相应的缓存），第一次获取缓存如果没有Cache组件会自动创建。
• 2、去Cache中查找缓存的内容，使用一个key，默认就是方法的参数；key是按照某种策略生成的；默认是使用keyGenerator生成的，默认使用SimpleKeyGenerator生成key；如果没有参数；key=new SimpleKey()；如果有一个参数：key=参数的值；如果有多个参数：key=new SimpleKey(params)；
• 3、没有查到缓存就调用目标方法；
• 4、将目标方法返回的结果，放进缓存中

五、整合Ehcache

Ehcache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存,Java EE和轻量级容器。它具有内存和磁盘存储，缓存加载器,缓存扩展,缓存异常处理程序,一个gzip缓存servlet过滤器,支持REST和SOAP api等特点。

5.1 导入依赖

整合ehcache必须要导入它的依赖。

        <dependency>
            <groupId>net.sf.ehcache</groupId>
            <artifactId>ehcache</artifactId>
        </dependency>

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

5.2 yml配置

需要说明的是config: classpath:/ehcache.xml可以不用写，因为默认就是这个路径。但ehcache.xml必须有。

spring:
  cache:
    type: ehcache
    ehcache:
      config: classpath:/ehcache.xml

5.3 ehcache.xml配置

在resources目录下新建ehcache.xml，注释啥的应该可以说相当详细了：

<ehcache>

    <!--
        磁盘存储:将缓存中暂时不使用的对象,转移到硬盘,类似于Windows系统的虚拟内存
        path:指定在硬盘上存储对象的路径
        path可以配置的目录有：
            user.home（用户的家目录）
            user.dir（用户当前的工作目录）
            java.io.tmpdir（默认的临时目录）
            ehcache.disk.store.dir（ehcache的配置目录）
            绝对路径（如：d:\\ehcache）
        查看路径方法：String tmpDir = System.getProperty("java.io.tmpdir");
     -->
    <diskStore path="java.io.tmpdir" />

    <!--
        defaultCache:默认的缓存配置信息,如果不加特殊说明,则所有对象按照此配置项处理
        maxElementsInMemory:设置了缓存的上限,最多存储多少个记录对象
        eternal:代表对象是否永不过期 (指定true则下面两项配置需为0无限期)
        timeToIdleSeconds:最大的发呆时间 /秒
        timeToLiveSeconds:最大的存活时间 /秒
        overflowToDisk:是否允许对象被写入到磁盘
        说明：下列配置自缓存建立起600秒(10分钟)有效 。
        在有效的600秒(10分钟)内，如果连续120秒(2分钟)未访问缓存，则缓存失效。
        就算有访问，也只会存活600秒。
     -->
    <defaultCache maxElementsInMemory="10000" eternal="false"
                  timeToIdleSeconds="600" timeToLiveSeconds="600" overflowToDisk="true" />

    <cache name="myCache" maxElementsInMemory="10000" eternal="false"
                  timeToIdleSeconds="120" timeToLiveSeconds="600" overflowToDisk="true" />

</ehcache>

5.4 使用缓存

@CacheConfig(cacheNames = {“myCache”})设置ehcache的名称，这个名称必须在ehcache.xml已配置 。

@CacheConfig(cacheNames = {"myCache"})
public class BotRelationServiceImpl implements BotRelationService {

    @Cacheable(key = "targetClass + methodName +#p0")
    public List<BotRelation> findAllLimit(int num) {
        return botRelationRepository.findAllLimit(num);
    }
}

六、整合Redis

Redis 优势

• 性能极高 – Redis能读的速度是110000次/s,写的速度是81000次/s 。
• 丰富的数据类型 – Redis支持二进制案例的 Strings, Lists, Hashes, Sets 及 Ordered Sets 数据类型操作。
• 原子 – Redis的所有操作都是原子性的，意思就是要么成功执行要么失败完全不执行。单个操作是原子性的。多个操作也支持事务，即原子性，通过MULTI和EXEC指令包起来。
• 丰富的特性 – Redis还支持 publish/subscribe, 通知, key 过期等等特性

6.1 启动Redis#

下载地址：https://github.com/MicrosoftArchive/redis/releases

6.2 导入依赖

就只需要这一个依赖！不需要spring-boot-starter-cache；

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

当你导入这一个依赖时，SpringBoot的CacheManager就会使用RedisCache。

如果你的Redis使用默认配置，这时候已经可以启动程序了。

6.3 配置Redis

# Redis数据库索引（默认为0）
spring.redis.database=1
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=1000
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.pool.max-idle=10
# 连接池中的最小空闲连接
spring.redis.pool.min-idle=2
# 连接超时时间（毫秒）
spring.redis.timeout=0

6.4 配置RedisCacheManager

自定义RedisCacheManager，一般都是为了自定义控制RedisTemplate序列化方式。