springboot集成redis redis失效监听实现定时业务

朱雀 2022-03-15 11:11 219阅读 0赞

### 文章目录 ###

*   *   *   *  源码
             *  redis
             *  redis 分布式锁
             *  鉴定redis过期的key。实现定时处理需求

#### [源码][Link 1] ####

#### redis ####

1.  引入 redis 开发包
    
        <?xml version="1.0" encoding="UTF-8"?>
        <project xmlns="http://maven.apache.org/POM/4.0.0"
                 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
            <parent>
                <artifactId>springboot-integrate</artifactId>
                <groupId>springboot-integrate</groupId>
                <version>1.0-SNAPSHOT</version>
            </parent>
            <modelVersion>4.0.0</modelVersion>
        
            <artifactId>springboot-redis</artifactId>
        
            <dependencies>
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-web</artifactId>
                </dependency>
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-data-redis</artifactId>
                </dependency>
            </dependencies>
        
            <build>
                <plugins>
                    <plugin>
                        <groupId>org.springframework.boot</groupId>
                        <artifactId>spring-boot-maven-plugin</artifactId>
                        <configuration>
                            <mainClass>com.integrate.rabbitmq.RabbitmqApplication</mainClass>
                        </configuration>
                    </plugin>
                </plugins>
            </build>
        </project>
2.  redis 配置 写入 application.yml。springboot 会自动加载配置信息,创建RedisConnectionFactory实例
    
        spring:
          application:
            name: springboot-redis
          #redis配置数据
          redis:
            host: 192.168.1.22
            port: 6379
            database: 2
            password:
            jedis:
              pool:
                # 可以在给定的池中分配的最大连接数
                maxActive: 8
                # 池中的“空闲”连接的最大数目
                maxIdle: 0
                # 池中要维护的最小空闲连接数
                minIdle: 8
            ssl: false
            timeout: 5000
        server:
          port: 10003
3.  配置 redis 序列化类型
    
        package com.integrate.redis.config;
        
        import org.springframework.context.annotation.Bean;
        import org.springframework.context.annotation.Configuration;
        import org.springframework.context.annotation.Primary;
        import org.springframework.data.redis.connection.RedisConnectionFactory;
        import org.springframework.data.redis.core.RedisTemplate;
        import org.springframework.data.redis.core.StringRedisTemplate;
        import org.springframework.data.redis.listener.RedisMessageListenerContainer;
        import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
        import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
        import org.springframework.data.redis.serializer.StringRedisSerializer;
        
        /** * @author admin */
        @Configuration
        public class RedisConfig { 
        
            @Bean(name = "redisTemplateJdk" )
            public <T> RedisTemplate<String, T> redisTemplateJdk(RedisConnectionFactory redisConnectionFactory) { 
                RedisTemplate redisTemplate = new StringRedisTemplate();
                redisTemplate.setConnectionFactory(redisConnectionFactory);
        
                redisTemplate.setKeySerializer(new StringRedisSerializer());
                redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer());
                redisTemplate.afterPropertiesSet();
                return redisTemplate;
            }
        
            @Bean(name = "redisTemplate" )
            @Primary
            public <T> RedisTemplate<String, T> redisTemplate(RedisConnectionFactory redisConnectionFactory) { 
                RedisTemplate redisTemplate = new StringRedisTemplate();
                redisTemplate.setConnectionFactory(redisConnectionFactory);
        
                redisTemplate.setKeySerializer(new StringRedisSerializer());
                redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
                redisTemplate.afterPropertiesSet();
                return redisTemplate;
            }
        
            @Bean(name = "redisTemplateStr" )
            public <T> RedisTemplate<String, String> redisTemplateStr(RedisConnectionFactory redisConnectionFactory) { 
                RedisTemplate redisTemplate = new StringRedisTemplate();
                redisTemplate.setConnectionFactory(redisConnectionFactory);
        
                redisTemplate.setKeySerializer(new StringRedisSerializer());
                redisTemplate.setValueSerializer(new StringRedisSerializer());
                redisTemplate.afterPropertiesSet();
                return redisTemplate;
            }
        }
    
    1.  redisTemplateJdk Jdk序列化。redis可以存入jdk序列化后的字符串。取出来后可以反序列化为对象
    2.  redisTemplate GenericJackson2Json 序列化 对象已json的形式存储在redis中
    3.  redisTemplateStr String 序列化
    4.  @Primary redisTemplate 为默认实例，当未指定实例时，自动装配redisTemplate实例
4.  测试 redis
    
        @Autowired
            private RedisTemplate redisTemplate;
            
            // set
            redisTemplate.opsForValue().set(key,val);
            // get 
            Object object = redisTemplate.opsForValue().get(key);
            // 设置过期
            redisTemplate.expire(key,10, TimeUnit.SECONDS);
            // 删除
            redisTemplate.delete(key);
            // redis list数据结构
            redisTemplate.opsForList().rightPushAll("list", list);
            // 取出list
            List<String> stringList = redisTemplate.opsForList().range("list", 0, -1);
        
        
            @Autowired
            @Qualifier("redisTemplateJdk")
            private RedisTemplate redisTemplateJdk;
            // 使用redisTemplateJdk 存储序列化后的list
            redisTemplateJdk.opsForValue().set("listJDK",list);
            
            // 取出序列化后的list
            object = redisTemplateJdk.opsForValue().get("listJDK");
            list = (List<String>) object;
            .
            .
            .

#### redis 分布式锁 ####

1.  基于setnx 命令实现
    
        package com.integrate.redis.config;
        
        import org.springframework.beans.factory.annotation.Autowired;
        import org.springframework.data.redis.core.RedisCallback;
        import org.springframework.data.redis.core.RedisTemplate;
        import org.springframework.stereotype.Component;
        
        import java.util.concurrent.TimeUnit;
        
        /** * @author 刘志强 * @date 2020/8/10 11:36 * redis分布式锁 */
        @Component
        public class RedisLock { 
        
            @Autowired
            private RedisTemplate redisTemplate;
        
            /** * 获得锁 ture 获得锁 false 没有获得锁 * @param key * @return */
            public Boolean getLock(String key) { 
                Boolean on;
                on = (Boolean) redisTemplate.execute(
                        (RedisCallback<Boolean>) conn -> { 
                            try { 
                                Boolean on1 =  conn.setNX(redisTemplate.getStringSerializer().serialize(key),
                                        redisTemplate.getStringSerializer().serialize(key));
                                if (on1) { 
                                    // 防止死锁。 10秒后删除key
                                    redisTemplate.expire(key, 10, TimeUnit.SECONDS);
                                }
                                return on1;
                            } finally { 
                                // 关闭释放链接
                                conn.close();
                            }
                        });
                return on;
            }
        
            /** * 释放锁 * @param key */
            public void unLock(String key) { 
                redisTemplate.delete(key);
            }
        
        
            /** * 等待获取锁 * @param key * @param second */
            public Boolean waitLock(String key, Long second) throws InterruptedException { 
                Boolean on;
                for (int i = 0; i < second; i++) { 
                    on = getLock(key);
                    if (on) { 
                        return true;
                    }
                    Thread.sleep(1000);
                }
                return  false;
            }
        
        }
2.  使用
    
        @Autowired
            private RedisLock redisLock;
            
            if (redisLock.getLock(key)) { 
                    // 处理程序
                    // ....
                    // ......
                    // 程序处理结束 删除释放锁
                    redisLock.unLock(key);
            } else { 
                    // 此任务已被别的程序处理
            }

#### 鉴定redis过期的key。实现定时处理需求 ####

1.  查看 redis 是否开启了到期通知事件。 设置redis
    
        // 设置
        192.168.1.22:6379> CONFIG set notify-keyspace-events Ex
        // 查看
        192.168.1.22:6379> CONFIG GET notify-keyspace-events
    
    相关参数说明
    
    <table> 
     <thead> 
      <tr> 
       <th>参数</th> 
       <th>说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>K</td> 
       <td>键空间通知，所有通知以 keyspace@ 为前缀，针对Key</td> 
      </tr> 
      <tr> 
       <td>E</td> 
       <td>键事件通知，所有通知以 keyevent@ 为前缀，针对event</td> 
      </tr> 
      <tr> 
       <td>g</td> 
       <td>DEL 、 EXPIRE 、 RENAME 等类型无关的通用命令的通知</td> 
      </tr> 
      <tr> 
       <td>$</td> 
       <td>字符串命令的通知</td> 
      </tr> 
      <tr> 
       <td>l</td> 
       <td>列表命令的通知</td> 
      </tr> 
      <tr> 
       <td>s</td> 
       <td>集合命令的通知</td> 
      </tr> 
      <tr> 
       <td>h</td> 
       <td>哈希命令的通知</td> 
      </tr> 
      <tr> 
       <td>z</td> 
       <td>有序集合命令的通知</td> 
      </tr> 
      <tr> 
       <td>x</td> 
       <td>过期事件：每当有过期键被删除时发送</td> 
      </tr> 
      <tr> 
       <td>e</td> 
       <td>驱逐(evict)事件：每当有键因为 maxmemory 政策而被删除时发送</td> 
      </tr> 
      <tr> 
       <td>A</td> 
       <td>参数 g$lshzxe 的别名，相当于是All</td> 
      </tr> 
     </tbody> 
    </table>
2.  创建RedisMessageListenerContainer Bean redis监听容器
    
        @Bean(name = "redisMessageListenerContainer")
            RedisMessageListenerContainer redisMessageListenerContainer(RedisConnectionFactory connectionFactory) {
                RedisMessageListenerContainer container = new RedisMessageListenerContainer();
                container.setConnectionFactory(connectionFactory);
                return container;
            }
3.  声明一个 函数式接口, 处理到期事件
    
        package com.integrate.redis.config.listener;
        
        /**
         * @author 刘志强
         * @date 2020/12/1 11:16
         */
        @FunctionalInterface
        public interface MethodInterface {
            /**
             * 执行的接口
             */
            void execute();
        }
4.  创建 redis 到期监听器
    
        package com.integrate.redis.config.listener;
        
        import org.springframework.beans.factory.annotation.Autowired;
        import org.springframework.beans.factory.annotation.Qualifier;
        import org.springframework.data.redis.connection.Message;
        import org.springframework.data.redis.core.RedisTemplate;
        import org.springframework.data.redis.listener.KeyExpirationEventMessageListener;
        import org.springframework.data.redis.listener.RedisMessageListenerContainer;
        import org.springframework.stereotype.Component;
        
        import java.util.HashMap;
        import java.util.Map;
        import java.util.concurrent.TimeUnit;
        
        /**
         * @author 刘志强
         * @date 2020/12/1 10:47
         */
        @Component
        public class RedisKeyExpirationListener extends KeyExpirationEventMessageListener {
        
            @Autowired
            private RedisTemplate redisTemplate;
        
            public RedisKeyExpirationListener(@Qualifier("redisMessageListenerContainer") RedisMessageListenerContainer listenerContainer) {
                super(listenerContainer);
            }
        
            private static Map<String, MethodInterface> methodInterfaceMap = new HashMap<>();
        
        
            /**
             * 将key val存储至redis 并设置过期时间
             * 将methodInterface绑定至map中
             * @param key
             * @param val
             * @param millisecond
             * @param methodInterface
             * @return
             */
            public Boolean monitorSet(String key,String val,Long millisecond, MethodInterface methodInterface) {
                redisTemplate.opsForValue().set(key,val);
                Boolean aBoolean = redisTemplate.expire(key,millisecond, TimeUnit.MILLISECONDS);
                methodInterfaceMap.put(key,methodInterface);
                return aBoolean;
            }
        
        
            @Override
            public void onMessage(Message message, byte[] pattern) {
                String expiredKey = message.toString();
                methodInterfaceMap.forEach((k,v) -> {
                    if (k.equals(expiredKey)) {
                        // 从map中去除对应的方法执行
                        v.execute();
                    }
                });
                // 清除map中的对象释放内存
                if (methodInterfaceMap.get(expiredKey) != null) {
                    methodInterfaceMap.remove(expiredKey);
                }
            }
        }
5.  测试controller
    
        @GetMapping("redisExpireSet")
            public String redisExpireSet(String key,String val,Long millisecond) {
                redisKeyExpirationListener.monitorSet(key,val,millisecond,() -> {
                    log.info(key+ "已到期");
                });
                return "已设置";
            }

[Link 1]: https://gitee.com/lzq199528/springboot-integrate/tree/master/springboot-redis