springboot使用redis的keyspace notifications

简单定时任务解决方案：使用redis的keyspace notifications（键失效后通知事件）
需要注意此功能是在redis 2.8版本以后推出的，因此你服务器上的reids最少要是2.8版本以上；

(A)业务场景：
1、当一个业务触发以后需要启动一个定时任务，在指定时间内再去执行一个任务
2、redis的keyspace notifications 会在key失效后发送一个事件，监听此事件的的客户端就可以收到通知
(B)服务准备：
    1、修改reids配置文件（redis.conf）
        redis默认不会开启keyspace notifications，因为开启后会对cpu有消耗
        备注：
            E：keyevent事件，事件以__keyevent@__为前缀进行发布；
            x：过期事件，当某个键过期并删除时会产生该事件；
        配置如下：
            notify-keyspace-events "Ex"
    2、重启redis就可以了,我们测试一下我们有没有修改成功。
    开启一个客户端用来监听：
        [[email protected] ~]$ redis-cli
        127.0.0.1:6379> psubscribe __keyevent@0__:expired
        Reading messages... (press Ctrl-C to quit)
        1) "psubscribe"
        2) "__keyevent@0__:expired"
        3) (integer) 1
    开启一个发送key的客户端：
        [[email protected] ~]$ redis-cli
        127.0.0.1:6379> set testKey 123 PX 100
        OK
        127.0.0.1:6379>
    结果：
        [[email protected] ~]$ redis-cli
        127.0.0.1:6379> psubscribe __keyevent@0__:expired
        Reading messages... (press Ctrl-C to quit)
        1) "psubscribe"
        2) "__keyevent@0__:expired"
        3) (integer) 1
        1) "pmessage"
        2) "__keyevent@0__:expired"
        3) "__keyevent@0__:expired"
        4) "testKey"
    这样代表测试成功！

(C)springBoot工程引用
    1、配置文件 application.properties加入如下配置

spring.redis.host=127.0.0.1
spring.redis.pool.max-active=8
spring.redis.pool.max-idle=8
spring.redis.pool.max-wait=-1
spring.redis.pool.min-idle=0
spring.redis.timeout=3000
spring.redis.password=123456
spring.redis.port=6379

    2、在com.xxx.xxx下添加RedisConfiguration类 

package com.xxx.xxx;
        import org.slf4j.Logger;
        import org.slf4j.LoggerFactory;
        import org.springframework.beans.factory.annotation.Value;
        import org.springframework.cache.annotation.CachingConfigurerSupport;
        import org.springframework.context.annotation.Bean;
        import org.springframework.stereotype.Component;
        import redis.clients.jedis.JedisPool;
        import redis.clients.jedis.JedisPoolConfig;
        /**
         * Created by test on 2017/2/12.
         */
        @Component
        public class RedisConfiguration extends CachingConfigurerSupport {
            Logger logger = LoggerFactory.getLogger(RedisConfiguration.class);
            @Value("${spring.redis.host}")
            private String host;

            @Value("${spring.redis.port}")
            private int port;

            @Value("${spring.redis.timeout}")
            private int timeout;

            @Value("${spring.redis.pool.max-idle}")
            private int maxIdle;

            @Value("${spring.redis.pool.max-wait}")
            private long maxWaitMillis;

            @Value("${spring.redis.password}")
            private String password;

            @Bean
            public JedisPool redisPoolFactory() {
                logger.info("JedisPool注入成功！！");
                logger.info("redis地址：" + host + ":" + port);
                JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
                jedisPoolConfig.setMaxIdle(maxIdle);
                jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);

                JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout,password);
                return jedisPool;
            }
        }

    3、在com.xxx.xxx下创建redisKeyspace包
    并创建一个Subscribe.java类
        package com.xxx.xxx.redisKeyspace;
        import org.apache.commons.logging.Log;
        import org.apache.commons.logging.LogFactory;
        import redis.clients.jedis.JedisPubSub;
        /**
         * Created by test on 2017/2/12.
         */
        public class Subscribe extends JedisPubSub {
            private static final Log log= LogFactory.getLog(Subscribe.class);
            // 初始化按表达式的方式订阅时候的处理
            public void onPSubscribe(String pattern, int subscribedChannels) {
                log.info("Subscribe-onPSubscribe>>>>>>>>>>>>>>>>>>>>>>>>"+pattern + "=" + subscribedChannels);
            }
            // 取得按表达式的方式订阅的消息后的处理
            public void onPMessage(String pattern, String channel, String message) {
                try {
                    log.info(pattern + "=" + channel + "=" + message);
                    //在这里写你相关的逻辑代码
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }

3、创建SubscribeThread.java线程类    
备注：此线程实现了CommandLineRunner，springBoot的CommandLineRunner 可以达到工程已启动就开启一个线程        

package com.xxx.xxx.redisKeyspace;
        import org.apache.commons.logging.Log;
        import org.apache.commons.logging.LogFactory;
        import org.springframework.beans.factory.annotation.Autowired;
        import org.springframework.boot.CommandLineRunner;
        import org.springframework.stereotype.Component;
        import redis.clients.jedis.Jedis;
        import redis.clients.jedis.JedisPool;
        /**
         * Created by test on 2017/2/13.
         */
        @Component
        public class SubscribeThread implements CommandLineRunner {
            private Log log= LogFactory.getLog(SubscribeThread.class);
            @Autowired
            JedisPool jedisPool;
            @Override
            public void run(String... strings) throws Exception {
                Jedis jedis= jedisPool.getResource();
                try {
                    //监听所有reids通道中的过期事件
                    jedis.psubscribe(new Subscribe(), "*");
                } catch (Exception e) {
                    jedis.close();
                    e.printStackTrace();
                }finally {
                    jedis.close();
                }
            }
        }

4、具体业务中向redis中添加key

/**
         * 添加redis秒定时任务
         * @param seconds 秒
         */
        private void addRedisTimer(String key,int seconds) {
            Jedis jedis = jedisPool.getResource();
            try {
                if (!jedis.exists(key))
                    jedis.setex(key,seconds,"");
            }catch (Exception e){
                logger.error("addRedisTimer error: ", e);
            }finally {
                jedis.close();
            }
        }

这样我们就实现了springboot已启动就开启一个线程用来监听reids的keyspace notifications事件，然后接收到事件后处理相应的业务代码