1: Abstração de cache Spring
Spring definiu as interfaces org.springframework.cache.Cache e org.springframework.cache.CacheManager desde 3.1 para unificar diferentes tecnologias de cache e suporta o uso de anotações JCache (JSR-107) para simplificar nosso desenvolvimento;
A interface Cache é definida na especificação do componente de cache e inclui uma coleção de diversas operações de cache;
Na interface Cache, Spring fornece várias implementações de xxxCache, como RedisCache, EhCacheCache, ConcurrentMapCache, etc.;
Cada vez que um método que requer cache é chamado, o Spring verificará se o método de destino especificado com os parâmetros especificados foi chamado; em caso afirmativo, ele obterá diretamente o resultado da chamada do método do cache; caso contrário, ele chamará o método e armazenar em cache o resultado. Retornar ao usuário. A próxima chamada será obtida diretamente do cache.
Precisamos prestar atenção aos dois pontos a seguir ao usar a abstração de cache Spring;
1. Determine os métodos que precisam ser armazenados em cache e sua estratégia de armazenamento em cache
2. Leia os dados armazenados em cache anteriormente no cache
2: Vários conceitos importantes e anotações de cache
nome | explicar |
---|---|
Cache | Interface de cache, que define as operações de cache. As implementações incluem: RedisCache, EhCacheCache, ConcurrentMapCache, etc. |
CacheManager | Gerenciador de cache, gerencia vários componentes de cache |
@Cacheável | Principalmente para configuração do método, ele pode ser armazenado em cache de acordo com os parâmetros de solicitação do método. |
@CacheEvict | Esvaziar o cache |
@CachePut | Certifique-se de que o método seja chamado e espere que o resultado seja armazenado em cache. A diferença de @Cacheable é se o método é chamado sempre, o que é frequentemente usado para atualizações |
@EnableCaching | Habilitar cache baseado em anotações |
gerador de chaves | Estratégia de geração de chave ao armazenar dados em cache |
serializar | Estratégia de serialização de valor ao armazenar dados em cache |
@CacheConfig | Configure uniformemente as propriedades das anotações de cache desta classe |
Parâmetros principais @Cacheable/@CachePut/@CacheEvict
nome | explicar |
---|---|
valor | O nome do cache, definido no arquivo de configuração do Spring, deve especificar pelo menos um exemplo: @Cacheable(value=”mycache”) ou @Cacheable(value={”cache1”,”cache2”} |
chave | A chave de cache pode estar vazia. Se for especificada para ser escrita de acordo com a expressão SpEL, se não for especificada, será combinada de acordo com todos os parâmetros do método por padrão. Por exemplo: @Cacheable(value="testcache", key ="#id") |
doença | A condição de cache pode estar vazia, escrita em SpEL e retornar verdadeiro ou falso. Somente quando for verdadeiro o cache será armazenado em cache/limpo. Por exemplo: @Cacheable(value="testcache",condition="#userName.length ()>2") |
a menos que | Negar cache. Quando o resultado da condição for TRUE, ele não será armazenado em cache. @Cacheable(value="testcache",unless="#userName.length()>2") |
allEntries(@CacheEvict) | Se deve ser limpo todo o conteúdo do cache. O padrão é falso. Se verdadeiro for especificado, todos os caches serão limpos imediatamente após o método ser chamado. Por exemplo: @CachEvict(value="testcache", allEntries=true) |
beforeInvocation(@CacheEvict) | Se deve ser limpo antes da execução do método. O padrão é falso. Se verdadeiro for especificado, o cache será limpo antes da execução do método. Por padrão, se uma exceção for lançada durante a execução do método, o cache não será limpo. Para exemplo: @CachEvict(value="testcache", beforeInvocation=true) |
Três: dados de contexto SpEL
Spring Cache fornece alguns dados de contexto SpEL para usarmos.A tabela a seguir foi retirada diretamente da documentação oficial do Spring:
nome | Localização | descrever | Exemplo |
---|---|---|---|
nome do método | objeto raiz | O nome do método atualmente chamado | #root.nomedometodo |
método | objeto raiz | O método atualmente sendo chamado | #root.metodo.nome |
alvo | objeto raiz | A instância do objeto de destino que está sendo chamada no momento | #root.target |
classealvo | objeto raiz | A classe do objeto alvo atualmente sendo chamado | #root.targetClass |
argumentos | objeto raiz | A lista de parâmetros do método atualmente chamado | #root.args[0] |
esconderijos | objeto raiz | A lista de cache usada pela chamada de método atual | #root.caches[0].nome |
Nome do argumento | contexto de execução | Os parâmetros do método atualmente chamado, como findArtisan(Artisan Craft), podem ser obtidos através de #artsian.id | #artsian.id |
resultado | contexto de execução | O valor de retorno após a execução do método (válido somente após a execução do método, como a menos que o beforeInvocation=false do cacheEvict) | #resultado |
Perceber:
1. Quando queremos usar os atributos do objeto raiz como chave, também podemos omitir "#root", pois o Spring usa os atributos do objeto raiz por padrão. como
@Cacheable(chave = “targetClass + nomedométodo +#p0”)
2. Ao usar parâmetros de método, podemos usar diretamente "#parameter name" ou "#pparameter index". como:
@Cacheable(valor=“usuários”, key="#id")
@Cacheable(valor=“usuários”, key="#p0")
SpEL oferece uma variedade de operadores
tipo | operador |
---|---|
relação | <,>,<=,>=,==,!=,lt,gt,le,ge,eq,ne |
aritmética | +,- ,* ,/,%,^ |
lógica | &&,ll,!,e,ou,não,entre,instânciade |
doença | ?: (ternário),?: (elvis) |
expressão regular | partidas |
Outros tipos | ?.,?[…],![…],$[…] |
Os pontos de conhecimento acima são adequados para você consultar quando esquecer. Vamos começar oficialmente a aprender!
Quatro: comece
Ambiente: Spring boot 2.0.3
IDEIA: IDEIA
1. Você precisa importar dependências antes de começar a usá-lo.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>
2. Em seguida, anote @EnableCaching na classe de inicialização para habilitar o cache
@SpringBootApplication
@EnableCaching //开启缓存
public class DemoApplication{
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
3. Cache @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 的作用 主要针对方法配置,能够根据一定的条件对缓存进行清空 。
属性 | 解释 | 示例 |
---|---|---|
allEntries | 是否清空所有缓存内容,缺省为 false,如果指定为 true,则方法调用后将立即清空所有缓存 | @CachEvict(value=”testcache”,allEntries=true) |
beforeInvocation | 是否在方法执行前就清空,缺省为 false,如果指定为 true,则在方法还没有执行的时候就清空缓存,缺省情况下,如果方法执行抛出异常,则不会清空缓存 | @CachEvict(value=”testcache”,beforeInvocation=true) |
示例:
@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) {
....
}
下面讲到的整合第三方缓存组件都是基于上面的已经完成的步骤,所以一个应用要先做好你的缓存逻辑,再来整合其他cache组件。
五:整合EHCACHE
Ehcache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存,Java EE和轻量级容器。它具有内存和磁盘存储,缓存加载器,缓存扩展,缓存异常处理程序,一个gzip缓存servlet过滤器,支持REST和SOAP api等特点。
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>
2.yml配置
需要说明的是config: classpath:/ehcache.xml可以不用写,因为默认就是这个路径。但ehcache.xml必须有。
spring:
cache:
type: ehcache
ehcache:
config: classpath:/ehcache.xml
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>
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 过期等等特性
1.启动Redis
下载地址:https://github.com/MicrosoftArchive/redis/releases
这里写图片描述
2.导入依赖
就只需要这一个依赖!不需要spring-boot-starter-cache
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
当你导入这一个依赖时,SpringBoot的CacheManager就会使用RedisCache。
如果你的Redis使用默认配置,这时候已经可以启动程序了。
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
4.模板编程
除了使用注解,我们还可以使用Redis模板。
Spring boot集成 Redis 客户端jedis。封装Redis 连接池,以及操作模板。
@Autowired
private StringRedisTemplate stringRedisTemplate;//操作key-value都是字符串
@Autowired
private RedisTemplate redisTemplate;//操作key-value都是对象
/**
* Redis常见的五大数据类型:
* stringRedisTemplate.opsForValue();[String(字符串)]
* stringRedisTemplate.opsForList();[List(列表)]
* stringRedisTemplate.opsForSet();[Set(集合)]
* stringRedisTemplate.opsForHash();[Hash(散列)]
* stringRedisTemplate.opsForZSet();[ZSet(有序集合)]
*/
public void test(){
stringRedisTemplate.opsForValue().append("msg","hello");}