Introducción y uso de Spring Cache

Tabla de contenido

1. Anotaciones comunes para Spring Cache

2. Spring Cache utiliza pasos de almacenamiento en caché de Redis

1. Introducción a Spring Cache

Spring cache es un marco que implementa funciones de almacenamiento en caché basadas en anotaciones. Solo necesita agregar una anotación para implementar el almacenamiento en caché.

Función. Spring Cache proporciona una capa de abstracción y la capa inferior puede cambiar diferentes implementaciones de caché. Específicamente, CacheManager

Interfaz para unificar diferentes tecnologías de almacenamiento en caché.

CacheManager es una interfaz abstracta para varias tecnologías de almacenamiento en caché proporcionadas por Spring.

Es necesario implementar diferentes CacheManagers para diferentes tecnologías de almacenamiento en caché:

Administrador de caché	describir
EhcachecacheManager	Usando EhCache como tecnología de almacenamiento en caché
GuavaCacheManager	Usando GuavaCache de Google como tecnología de almacenamiento en caché
RedisCacheManager	Usando Redis como tecnología de almacenamiento en caché

1. Anotaciones comunes para Spring Cache

anotación	ilustrar
@EnableCaching	Habilitar la función de anotación de caché
@caché	Antes de ejecutar el método, Spring primero verifica si hay datos en el caché. Si hay datos, los devuelve directamente. Si no hay datos, llama al método y coloca el valor de retorno del método en el caché.
@CachePut	Poner el valor de retorno del método en el caché.
@CacheEvict	Eliminar uno o más datos del caché

En el proyecto Spring Boot, para usar la tecnología de almacenamiento en caché, solo necesita importar el paquete de dependencia de la tecnología de almacenamiento en caché relevante al proyecto y usarlo en la clase de inicio.

@EnableCaching puede habilitar la compatibilidad con el almacenamiento en caché.

Por ejemplo, para utilizar Redis como tecnología de almacenamiento en caché, solo necesita importar las coordenadas maven de Spring data Redis.

2. Spring Cache utiliza pasos de almacenamiento en caché de Redis

1. Agregar dependencias

         <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>

2. Agregar configuración

spring
  redis:
    host: 172.17.2.94  #ip地址
    port: 6379         #端口
    password: root@123456  #redis密码
    database: 0        #指定数据库
  cache:
    redis:
      time-to-live: 1800000 #设置缓存过期时间，可选

3. Utilice anotaciones

Anota la clase de inicio: @EnableCaching

@Slf4j
@SpringBootApplication
@EnableCaching
public class CacheDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(CacheDemoApplication.class,args);
        log.info("项目启动成功...");
    }
}

Anotación @CachePut: coloque el valor de retorno del método en la caché

    /**
     * CachePut：将方法返回值放入缓存
     * value：缓存的名称，每个缓存名称下面可以有多个key
     * key：缓存的key
     */
    //@CachePut(value = "userCache",key = "#result.id")//result带表返回值
    @CachePut(value = "userCache",key = "#user.id")//可以直接获取参数，参数名要保持一致
    @PostMapping
    public User save(User user){
        userService.save(user);
        return user;
    }

key admite el lenguaje de expresión de Spring, que puede calcular dinámicamente el valor de la clave y obtenerlo a través de #, generalmente usando parámetros #+ directos

resultado: representa el valor de retorno, puede obtener la clave obteniendo el valor de retorno

Anotación @CacheEvict: limpia el caché especificado

    /**
     * CacheEvict：清理指定缓存
     * value：缓存的名称，每个缓存名称下面可以有多个key
     * key：缓存的key
     */
    @CacheEvict(value = "userCache",key = "#p0")//p固定写法，0表示下表，第一个参数
    //@CacheEvict(value = "userCache",key = "#root.args[0]")//固定写法，0表示下表，第一个参数
    //@CacheEvict(value = "userCache",key = "#id")//直接获取参数
    @DeleteMapping("/{id}")
    public void delete(@PathVariable Long id){
        userService.removeById(id);
    }

    //@CacheEvict(value = "userCache",key = "#p0.id")//p0第一个参数，id参数的属性
    //@CacheEvict(value = "userCache",key = "#user.id")//直接获取参数属性
    //@CacheEvict(value = "userCache",key = "#root.args[0].id")//获取第一个参数，id参数的属性
    @CacheEvict(value = "userCache",key = "#result.id")//从返回值获取
    @PutMapping
    public User update(User user){
        userService.updateById(user);
        return user;
    }

Anotación @Cacheable: antes de ejecutar el método, Spring primero verifica si hay datos en el caché. Si hay datos, devuelve directamente los datos almacenados en caché. Si no hay datos, llama al método y coloca el valor de retorno del método en el caché.

/**
     * Cacheable：在方法执行前spring先查看缓存中是否有数据，如果有数据，则直接返回缓存数据；若没有数据，调用方法并将方法返回值放到缓存中
     * value：缓存的名称，每个缓存名称下面可以有多个key
     * key：缓存的key
     * condition：条件，满足条件时才缓存数据
     * unless：满足条件则不缓存
     */
    @Cacheable(value = "userCache",key = "#id",unless = "#result == null")
    @GetMapping("/{id}")
    public User getById(@PathVariable Long id){
        User user = userService.getById(id);
        return user;
    }

    @Cacheable(value = "userCache",key = "#user.id + '_' + #user.name")//动态拼接key
    @GetMapping("/list")
    public List<User> list(User user){
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(user.getId() != null,User::getId,user.getId());
        queryWrapper.eq(user.getName() != null,User::getName,user.getName());
        List<User> list = userService.list(queryWrapper);
        return list;
    }