One 、 Introduction to event notification

1、 Preface

Official references ：https://redis.io/docs/manual/keyspace-notifications/

from Redis 2.8.0 Start ,Redis Joined the Release / A subscription model as well as Key space message reminder （keyspace notification） function . Key space message reminders allow clients to subscribe to specified channels Redis The ability to change data . It should be noted that , Key space message alerts are not reliable , It does not confirm whether the subscriber has received the message . For example, a subscribed client is temporarily disconnected , Events that occur until the connection is restored will not be available again .

2、 Configuration details

Various versions Redis The configuration file ：https://redis.io/docs/manual/config/

It can be done by redis Of redis.conf Configuration in file notify-keyspace-events Parameter can specify what type of notification the server sends . The following is a description of some parameters . This feature is off by default .

redis> CONFIG GET notify-keyspace-events
1) "notify-keyspace-events"
2) ""
redis> CONFIG SET notify-keyspace-events KEA
OK
redis> CONFIG GET notify-keyspace-events
1) "notify-keyspace-events"
2) "AKE"

In the above example notify-keyspace-events Configure to KEA, It represents all events except for the fate . among ,K And E Represents two types of events ——Keyspace And Keyevent.

Keyspace Represents the message related to the event name , For example, subscribe to the operation event of the specified key ;Keyevent Represents the message related to the key name , For example, subscribe to the relevant key name of the key expiration event .

3、 Subscribe to specified events

After the configuration is complete , It can be done by SUBSCRIBE Command subscription specifies the channel to subscribe to one or more specified events . For example, through subscription [email protected]__:expired Realize subscription database 0 Key expiration event in

The format of the subscribed channel is __<type>@<db>__:<event>, It includes event types （keyspace or keyevent）、 database （ Like databases 0） And events （ for example expired） Three parts . in addition , It can also be done through PSUBSCRIBE The command subscribes to one or more channels matched by composite regular expressions . For example, through subscription __key*@*__:* subscribe Redis All events in all databases in .

4、 Command Events

Redis Different events are provided for many commands , In this article, some commands and their corresponding events will be introduced ：

• DEL： Occurs when a key is deleted del event

• EXPIRE、PEXPIRE、EXPIREAT as well as PEXPIREAT： When setting the timestamp of positive expiration time or future time , Then expire event , Otherwise del event （ Will be deleted immediately ）

• SET And similar SETEX、SETNX、GETSET： produce set event , If you use SETEX Then there will be expire event

• MSET： One will be generated for each key set event

• LPUSH、LPUSHX And RPUSH、RPUSHX： According to the direction of insertion lpush or rpush event

• RPOP、LPOP： Produce separately rpop And lpop event , If the last element in the list is removed , Will be produced at the same time del event

• LSET： produce lset event

• LREM： produce lrem event , Similarly, if the removed element is the last element in the list, it will be generated at the same time del event

• HSET、HSETNX as well as HMSET： Produce a hset event

• HDEL： Produce a hdel event , And when the hash table is empty after removal del event

• SADD： Produce a sadd event

• SREM： Produce a srem event , And when the set is empty after removal del event

• SMOVE： Generated in the original key srem Event and generated in the target key sadd event

• SINTERSTORE、SUNIONSTORE、SDIFFSTORE： Produce separately sinterstore、sunionstore as well as sdiffstore event , And when the result is an empty set and the target key exists , Will produce del event

• ZADD： No matter how many elements are added, only one zadd event

• ZREM： No matter how many elements are removed, only one zrem event , When the ordered set is empty after removal del event

• XADD： produce xadd event , If you use MAXLEN Subcommands may be generated at the same time xtrim event

• XDEL： produce xdel event

• PERSIST： If the expiration event associated with the corresponding key is successfully removed , Then persist event

• Occurs when the key expires expired event

• In achieving maxmemory Generated when key elimination occurs after the set memory value evicted event

• ……

For more command related events , Please refer to keyspace notification The related documents

5、 Some examples

Subscription key expiration event

redis1> SUBSCRIBE [email protected]__:expired
1) "subscribe"
2) "[email protected]__:expired"
3) (integer) 1
# redis2> SETEX greeting 1 "hello world"
#  wait for 1 Seconds later ：
1) "message"
2) "[email protected]__:expired"
3) "greeting"

Subscribe to all events

redis1> PSUBSCRIBE __key*@*__:*
1) "psubscribe"
2) "__key*@*__:*"
3) (integer) 1
# redis2> SET greeting "hello world"
1) "pmessage"
2) "__key*@*__:*"
3) "[email protected]__:greeting"
4) "set"
1) "pmessage"
2) "__key*@*__:*"
3) "[email protected]__:set"
4) "greeting"

Two 、SpringBoot Realization Redis Invalid listening event

1、 The scene that

be based on Redis Active event handling , such as ： When a user purchases a membership card and fails to pay within ten minutes , You need to use applet or APP Actively push the advantages of purchasing membership cards to users , Guide users to continue to complete payment and purchase, etc , Similar scenarios require users to After the specified time point Take the initiative to inform or continue to guide , Use Redis Expiration key Event grace 、 Fast implementation .

because Redis The subscription / Release is No, ACK Acknowledgement mechanism Of , Therefore, messages may be lost , If you want to ensure that the information is reliable , You should choose MQ Message queuing implementation ,

2、 Code implementation (Redis Stand-alone version )

2.1 Environmental preparation

Import correspondence redis rely on

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <version>2.3.12.RELEASE</version>
</dependency>

Set up application.yml Connection information

spring:
  redis:
    host: 127.0.0.1
    port: 6379
    database: 0
    password: 123456
    timeout: 20000
    lettuce:
      pool:
        max-active: 8
        max-wait: -1
        max-idle: 50
        min-idle: 0

Finally, change redis.conf To configure notify-keyspace-events

#  Default 
notify-keyspace-events "" 
#  Change to 
notify-keyspace-events Ex

2.2 Configured to monitor Bean

@Configuration
public class RedisConfig {
    
   
    /** * key Expired event subscription requires  */
    @Bean
    @ConditionalOnMissingBean(RedisMessageListenerContainer.class)
    RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory) {
    
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        // Connection pool settings 
        container.setConnectionFactory(connectionFactory);
        return container;
    }

}

2.3 Configured to monitor key

@Component
@Slf4j
public class RedisKeyExpirationListener extends KeyExpirationEventMessageListener {
    

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    private final String SET_NX = "setnx:";

    private final Integer database = 0;

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

    @Override
    protected void doRegister(RedisMessageListenerContainer listenerContainer) {
    
        String topic = "[email protected]"+database+"__:expired";
        log.info(" Configure which channel to listen to :"+topic);
        PatternTopic patternTopic = new PatternTopic(topic);
        //  Channels can be many , Multiple transmissions list
        listenerContainer.addMessageListener(this,patternTopic);
    }

    @Override
    public void onMessage(Message message, byte[] pattern) {
    
        //  Get expired key, You can do your own business 
        String expiredKey = message.toString();
        //  Look for what you need key Prefix 
        if(!expiredKey.startsWith("test")){
    
            return;
        }
        //  utilize redis setIfAbsent command , If it is empty set return true, If not empty return false, similar setnx Lock operation 
        Boolean aBoolean = stringRedisTemplate.opsForValue().setIfAbsent(SET_NX + expiredKey, String.valueOf(System.currentTimeMillis()),10, TimeUnit.SECONDS);
        if (aBoolean){
    
            //  Avoid repeated consumption when multiple services are listening , You can also lock and unlock 
            //  Be careful ： Only invalid key value , Can't get key Corresponding value value 
            System.out.println(expiredKey);
            //  The corresponding business code can be carried out here 
        }
    }
}

3、Redis Cluster event listening

Here is a brief idea , Because the cluster cannot be monitored , Then set up multiple redis Connect , For each redis Of key Monitoring after expiration , It is equivalent to registering multiple listeners , Finally, expire key Just filter

3、 ... and 、 Some of the problems

Reference resources ： Leader ： Who uses it again Redis Overdue monitoring enables closing orders , Get out of here ！

There are several ways to implement delayed tasks ：

1. Use rocketmq、rabbitmq、pulsar Wait for the delayed delivery function of the message queue

2. Use redisson Provided DelayedQueue

There are some schemes that are widely circulated but have fatal defects , Don't use it to implement deferred tasks

1. Use redis Expired monitoring for

2. Use rabbitmq The dead letter line

3. Use non persistent time wheels

Redis6.0 Learning notes

Redis The expiration monitoring mechanism realizes order timeout processing

Redis Out of date under cluster key monitor

SpringBoot monitor redis Be overdue key