[SpringBoot] 35. SpringBoot integra Redis para monitorear los eventos de expiración de claves

En proyectos de desarrollo reales, el monitoreo de eventos de vencimiento de claves se usa ampliamente, como: pedidos en horas extras pero no pagados, cupones vencidos, etc.

1. Descripción

Este artículo es una continuación de:
[SpringBoot] 34. SpringBoot integra Redis para implementar el almacenamiento serializado de objetos Java
. El conocimiento y el código involucrados en este artículo no se repetirán en este artículo

Dos, modificar el archivo de configuración de Redis

• 1. En el directorio de instalación de Redis
  
• 2. Busque el archivo redis.windows.conf y busque "notificar-keyspace-events"

Modificado a "notificar-keyspace-events Ex", para que nuestro Redis admita el monitoreo de eventos de expiración de claves

Tres, inyecte redisMessageListenerContainer

Nota : Este artículo parcial está conectado con el artículo anterior: [SpringBoot] 34. SpringBoot integra Redis para realizar el almacenamiento serializado de objetos Java , y la información de configuración no se repetirá en este artículo.

• 1. Inyecte un bean redisMessageListenerContainer en RedisConfig.java para monitorear

@Bean
RedisMessageListenerContainer redisMessageListenerContainer(RedisConnectionFactory connectionFactory) {
    
    
    RedisMessageListenerContainer container = new RedisMessageListenerContainer();
    // 监听所有库的key过期事件
    container.setConnectionFactory(connectionFactory);
    return container;
}

• 2. Cree una clase de escucha RedisKeyExpirationListener

Necesitamos crear una clase de caducidad de clave de escucha para implementar operaciones específicas cuando se activa el evento

package com.zyxx.common.redis;

import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.connection.Message;
import org.springframework.data.redis.listener.KeyExpirationEventMessageListener;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.stereotype.Component;

/**
 * 监听 Redis key 过期事件
 *
 * @Author Lizhou
 */
@Slf4j
@Component
public class RedisKeyExpirationListener extends KeyExpirationEventMessageListener {
    
    

    public RedisKeyExpirationListener(RedisMessageListenerContainer redisMessageListenerContainer) {
    
    
        super(redisMessageListenerContainer);
    }

    /**
     * 针对 redis 数据失效事件，进行数据处理
     */
    @Override
    public void onMessage(Message message, byte[] pattern) {
    
    
        // 拿到key
        log.info("监听Redis key过期，key：{}，channel：{}", message.toString(), new String(pattern));
    }
}

Podemos monitorear la información de la clave caducada y la información del canal.

• 3. API de operación

在 RedisUtils 中加入如下操作

```java
/**
 * 写入数据，并设置过期时间
 */
public boolean set(final String key, Object value, long time) {
    
    
    if (StringUtils.isBlank(key)) {
    
    
        return false;
    }
    try {
    
    
        template.opsForValue().set(key, value, time, TimeUnit.SECONDS);
        log.info("存入redis成功，key：{}，value：{}", key, value);
        return true;
    } catch (Exception e) {
    
    
        log.error("存入redis失败，key：{}，value：{}", key, value);
        e.printStackTrace();
    }
    return false;
}

Con este método, podemos guardar datos en Redis y establecer el tiempo de caducidad en segundos (S)
''

Cuatro, prueba

• 1. Casos de prueba

package com.zyxx.redistest;

import com.zyxx.redistest.common.RedisUtils;
import com.zyxx.redistest.common.UserInfo;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Date;

@SpringBootTest
class RedisTestApplicationTests {
    
    

    @Autowired
    private RedisUtils redisUtil;

    @Test
    void contextLoads() {
    
    
        UserInfo userInfo = new UserInfo();
        userInfo.setId(1);
        userInfo.setName("jack");
        userInfo.setCreateTime(new Date());
        // 放入redis，并设置过期时间为5秒
        redisUtil.set("user", userInfo, 5);
    }
}

Almacenamos una clave como "usuario" y un valor como los datos del objeto UserInfo en Redis, y establecemos el tiempo de vencimiento en 5 segundos.

Nota : Antes de probar, necesitamos comenzar nuestro proyecto para inyectar el Bean en nuestro contenedor, y el evento de monitoreo entrará en vigencia.

• 2. El resultado de la prueba
  
  muestra que nuestros datos se almacenaron correctamente en Redis.

5 segundos después ...

Se activa el evento de caducidad de la clave. En este momento, cuando obtengamos la clave caducada, podemos realizar algunos procesos comerciales en consecuencia.

Si encuentra deficiencias en la lectura, ¡deje un mensaje! ! !