Um artigo leva você a obter o Redis de integração do Spring Cache

1. Pré-configuração

Primeiro, W construímos um projeto Springboot e introduzimos dependências:
Spring Web, Spring cache, redis, Spring Security

Configure application.properties

spring.redis.host=192.168.176.128
spring.redis.port=6379
#给缓存取一个名字，后面会用到
spring.cache.cache-names=yolo

2. Uso do cache

（1）@CacheConfig

Esta anotação é usada na classe para descrever o nome do cache usado por todos os métodos da classe. Claro, não é necessário usar essa anotação e configurar diretamente o nome na anotação de cache específica. O código de amostra é o seguinte:

@Service
@CacheConfig(cacheNames = "yolo")
public class UserService {
    
    
}

Você pode ver que as chaves em cache adicionarão o nome:

（2） @Cacheable

Essa anotação é geralmente adicionada ao método de consulta para indicar que o valor de retorno de um método é armazenado em cache.Por padrão, a chave em cache é o parâmetro do método e o valor em cache é o valor de retorno do método. O código de amostra é o seguinte:

@Cacheable(key = "#id")
public User getUserById(Integer id,String username) {
    
    
    System.out.println("getUserById");
    return getUserFromDBById(id);
}

Quando existem vários parâmetros, vários parâmetros são usados ​​como a chave por padrão. Se você precisar apenas de um dos parâmetros como a chave, poderá @Cacheableespecificar a chave por meio do atributo de chave na anotação. O código acima significa que apenas o id é usado como cache. Key, se você tiver requisitos complexos para a chave, poderá personalizar o keyGenerator. Obviamente, o objeto raiz é fornecido no Spring Cache, que pode atingir alguns efeitos complexos sem definir keyGenerator:

Exemplo:

@Service
//用来描述该类中所有方法使用的缓存名称
@CacheConfig(cacheNames = "yolo")
public class UserService {
    
    
    //表示将该方法的返回值缓存起来
    @Cacheable
    public User getUserById(Integer id) {
    
    
        System.out.println("getUserById>>>" + id);
        User user = new User();
        user.setId(id);
        return user;
    }
}

Cache de teste:

Você pode ver que o método foi executado apenas uma vez, porque a segunda chamada não foi executada e o resultado armazenado em cache foi usado.

Quando os parâmetros passados ​​pela chamada não forem iguais, serão considerados como duas chamadas diferentes:

Quando a chave é especificada, o julgamento será feito de acordo com a diferença da chave. Se a chave for a mesma duas vezes, ela será chamada apenas uma vez:

Embora existam vários parâmetros aqui, você pode especificar uma chave, como especificar id como chave:

você pode ver que embora os parâmetros passados ​​sejam diferentes, ele é chamado apenas uma vez:

(3) Gerador de chave personalizado

Se você tiver requisitos complexos para a chave, poderá personalizar o keyGenerator
Por exemplo, o formato de chave que desejo aqui é:方法名：参数

//自定义 keyGenerator,将返回值当做 key
@Component
public class MyKeyGenerator implements KeyGenerator {
    
    
    @Override
    public Object generate(Object o, Method method, Object... objects) {
    
    
        //可以根据自己的需求返回 key
        return method.getName() + ":" + Arrays.toString(objects);
    }
}

Chave armazenada:

（4） @CacheEvict

Essa anotação geralmente é adicionada ao método de exclusão. Quando os dados no banco de dados são excluídos, os dados em cache relacionados também devem ser apagados automaticamente. Quando a anotação é usada, ela também pode ser configurada para ser excluída de acordo com certas condições (atributo de condição) ou configurada para limpar todos os caches. (Atributo AllEntries), o código de amostra é o seguinte:

  @CacheEvict
    public void deleteUserById(Integer id) {
    
    
        System.out.println("deleteUserById>>>" + id);
    }

Você pode ver que o cache não é usado pela segunda vez e é chamado novamente:

（5） @CachePut

Essa anotação geralmente é adicionada ao método de atualização. Quando os dados no banco de dados são atualizados, os dados no cache também são atualizados. Usando essa anotação, o valor de retorno do método pode ser atualizado automaticamente para a chave existente. O código de amostra é o seguinte:

  @CachePut(key = "#user.id")
    public User updateUserById(User user) {
    
    
        return user;
    }

Você pode ver que ele foi chamado apenas uma vez e o cache foi usado diretamente na segunda vez, mas o cache neste momento é o cache que foi atualizado.

Três, resumo

No Spring Boot, usando o cache Redis, você pode usar RedisTemplate para implementá-lo sozinho ou pode usar este método. Este método é uma interface unificada fornecida pelo Spring Cache. A implementação pode ser Redis, Ehcache ou outro suporte. Uma estrutura de cache padronizada. Desta perspectiva, o relacionamento entre Spring Cache e Redis e Ehcache é como o relacionamento entre JDBC e vários drivers de banco de dados.

Consulte o vídeo do irmão Yu