SpringBoot Redis, integração Ehcache e configuração multi-cache

Ehcache

Ehcache é uma estrutura de cache em processo de java puro. É o provedor de cache padrão do Hibernate. Pode ser usado sozinho. Geralmente usado em bibliotecas de três partes (mybatis, shiro, etc.), não é bom o suficiente para suporte distribuído. Múltiplos nós não podem ser sincronizados e geralmente é usado junto com o redis.

Comparação de Ehcache e Redis

O Ehcache armazena em cache diretamente na máquina virtual Java, o que é problemático para o compartilhamento de cache.
O Redis acessa o serviço de cache por meio de soquetes. Se for um único aplicativo ou um aplicativo com altos requisitos para acesso de cache, use Ehcache. Se for um sistema grande, há compartilhamento de cache, implantação distribuída e uso de Redis com grande conteúdo de cache.

Exemplo de uso de Ehcache

Introduzir dependências

<!-- Ehache -->
<dependency>
    <groupId>net.sf.ehcache</groupId>
    <artifactId>ehcache</artifactId>
    <version>2.10.5</version>
</dependency>

Ehcache.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">

    <!-- 磁盘缓存位置 -->
    <diskStore path="java.io.tmpdir/ehcache"/>

    <!-- 默认缓存 -->
    <defaultCache
            maxEntriesLocalHeap="10000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            maxEntriesLocalDisk="10000000"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU">
        <persistence strategy="localTempSwap"/>
    </defaultCache>

    <!-- HellowWorld 缓存-->
    <cache name="HelloWorldCache"
           maxEntriesLocalHeap="1000"
           eternal="false"
           timeToIdleSeconds="5"
           timeToLiveSeconds="5"
           overflowToDisk="false"
           memoryStoreEvictionPolicy="LRU"></cache>

</ehcache>

Caso de teste

@Test
public void test1(){
    
    

    String url = System.getProperty("user.dir");
    System.out.println(url);

    // 创建缓存管理器
    CacheManager cacheManager=CacheManager.create(url+"/javatests/resources/ehcache.xml");
    // 获取缓存对象
    Cache cache=cacheManager.getCache("HelloWorldCache");
    // 创建元素
    Element element=new Element("key1","value1");
    // 将元素添加到缓存
    cache.put(element);

    // 获取缓存
    Element element1=cache.get("key1");
    System.out.println(element1);
    System.out.println(element1.getObjectValue());

    // 删除元素
    cache.remove("key1");
    People people=new People(1,"张三","test");
    Element p1=new Element("test",people);
    cache.put(p1);

    // 获取缓存的信息
    Element element2 = cache.get("test");
    System.out.println(element2);

    // 刷新缓存
    cache.flush();

    // 关闭缓存管理器
    cacheManager.shutdown();
}

SpringBoot integra Ehcache

Introduzir dependências

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<!-- Ehache -->
<dependency>
    <groupId>net.sf.ehcache</groupId>
    <artifactId>ehcache</artifactId>
    <version>2.10.5</version>
</dependency>

A classe de inicialização adiciona uma anotação para abrir o cache

@SpringBootApplication
@EnableCaching
@MapperScan("com.li.mapper")
public class TestProjectApplication {
    
    

    public static void main(String[] args) {
    
    
        SpringApplication.run(TestProjectApplication.class);
    }
}

Applicaiton.properties

# ehcache配置地址
spring.cache.ehcache.config=ehcache.xml

ehache.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">

    <!-- 磁盘缓存位置 -->
    <diskStore path="java.io.tmpdir/ehcache"/>

    <!-- 默认缓存 -->
    <defaultCache
            maxEntriesLocalHeap="10000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            maxEntriesLocalDisk="10000000"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU">
        <persistence strategy="localTempSwap"/>
    </defaultCache>

    <!-- HellowWorld 缓存-->
    <cache name="helloworld"
           maxEntriesLocalHeap="1000"
           eternal="false"
           timeToIdleSeconds="5"
           timeToLiveSeconds="5"
           overflowToDisk="false"
           memoryStoreEvictionPolicy="LRU"/>
</ehcache>

Exemplo de teste

@RequestMapping("/ehcache/{key}")
@Cacheable(value = "helloworld",key = "#key",cacheManager = "ehacheCacheManager")
public String test4(@PathVariable("key") String key){
    
    
    logger.info("ehcahce,key={}",key);
    return key;
}

@RequestMapping("/default/{key}")
@Cacheable(value = "default",key="#key")
public String cacheDefaultTest(@PathVariable("key") String key) {
    
    
    logger.info("default,key={}", key);
    return "24";
}

Configuração multi-cache

Classe de configuração do cache: use Redisson e Ehache para configurar separadamente.

@Configuration
public class CatchConfig {
    
    

    private static final Logger logger= LoggerFactory.getLogger(CatchConfig.class);

    @Autowired
    RedissonClient client;

    @Bean("redissonCacherManager")
    @Primary
    public RedissonSpringCacheManager redissonSpringCacheManager(){
    
    
        RedissonSpringCacheManager cacheManager = new RedissonSpringCacheManager(client);
        logger.info("===========================RedissonSpringCacheManager配置");
        return cacheManager;
    }

    @Bean("ehacheCacheManager")
    public EhCacheCacheManager ehCacheCacheManager(){
    
    
        logger.info("===========================EhCacheCacheManager配置");
        return new EhCacheCacheManager();
    }

}

Exemplo de uso

@RequestMapping("/ehcache/{key}")
@Cacheable(value = "helloworld",key = "#key",cacheManager = "ehacheCacheManager")
public String test4(@PathVariable("key") String key){
    
    
    logger.info("ehcahce,key={}",key);
    return key;
}

Anotação de cache Spring

@Cacheable

Ele pode ser marcado em um método ou classe. Quando marcado em um método, significa que o método suporta cache. Quando marcado em uma classe, significa que todos os métodos dessa classe suportam cache. Para um método que suporta armazenamento em cache, o Spring armazenará em cache seu valor de retorno após ser chamado para garantir que da próxima vez que o método for executado com os mesmos parâmetros, o resultado possa ser obtido diretamente do cache sem a necessidade de executar o método novamente. Os parâmetros comuns são explicados a seguir.

parâmetro	significado
valor 、 cacheNames	O nome do cache, definido no arquivo de configuração, deve especificar pelo menos um.
chave	Chave em cache, pode estar vazia
cacheManager	Modo de cache, o projeto pode configurar vários modos de cache

@CachePut

Não importa o que aconteça, coloque o resultado de retorno do método no cache. Esta anotação não pergunta se há dados em cache, mas executa o método todas as vezes, colocando o resultado de retorno do método no cache, que é equivalente a atualizar os dados no cache todas as vezes, e os dados no cache são os mais recentes a cada vez Dados de cache uma vez.

@CacheEvict

@CacheEvict é usado para marcar métodos ou classes que precisam limpar os elementos do cache. Quando marcado em uma classe, significa que a execução de todos os métodos nela irá disparar a operação de limpeza do cache.

@Caching

Esta anotação pode combinar várias anotações para realizar anotações personalizadas.

O cache realmente armazena a chave na anotação como o valor de retorno do método da chave como o valor da chave, não o valor na anotação.