使用Redis sorted set实现集合设置member过期

在我们日常工作中，有许多这种逻辑

例如需要得到最近三分钟的cache list. 例如我们监控系统需要查询最近一分钟的数据。

总结说来就是 需要一个list存储对象，并且这个对象会无限制增长，需要设置过期.

普遍做法有两种：
1.一种就是简单的list，存储的对象带有expireTime，然后定时任务不停的拿到整个list并去除过期的member.

2.一种是把整个list的每个成员都当做一个key来存，然后分别设置超时时间，虽然解决了超时问题，但是显然这样实在太过于浪费，而且很多操作都需要得到size或者整个list，那么就需要keys “usercache_”。一旦成员过多，key太多，keys消耗非常大，不推荐.

---

使用sorted set实现

redis有一个sorted set，就是一个根据score排序的set。仔细一看，极为契合我们的需求！
话不多说，直接上代码！

/**
 * 聚合器
 * @author Mingchenchen
 *
 */
public class Aggregator {
    private RedisTemplate<String, Event> redisTemplate;
    private ZSetOperations<String, Event>  zSetOperations;

    /**
     * constructor
     * @param redisTemplate
     * @param expireMillions
     */
    public Aggregator(RedisTemplate<String, Event> redisTemplate){
        this.redisTemplate = redisTemplate;
        redisTemplate.setKeySerializer(new Serializer());
        redisTemplate.setValueSerializer(new EventSerializer());
        this.zSetOperations = redisTemplate.opsForZSet();
    }

    /**
     * 存入一条数据到sorted set
     * @param key
     * @param event
     */
    public boolean zset(String key, Event event){
        long now = System.currentTimeMillis();
        return zSetOperations.add(key, event, now);
    }

    /**
     * 取出整个set的所有记录
     * @param key
     * @return
     */
    public Set<Event> zgetAll(String key, long expireSec){
        long now = System.currentTimeMillis();
        long tts = now - expireSec * 1000;

        //下标用-1才能表示最大值  score和count要用-inf和+inf
        //return zSetOperations.rangeByScore(key, tts+1, -1);

        return zSetOperations.rangeByScore(key, tts+1, Long.MAX_VALUE);
    }

    /**
     * 查看匹配数目
     * @param key
     * @param expire:过期时间 单位是秒
     * @return
     */
    public long zCount(String key, long expireSec){
        long now = System.currentTimeMillis();
        long tts = now - expireSec * 1000;

        //下标用-1才能表示最大值  score和count要用-inf和+inf
        //return zSetOperations.count(key, tts+1, -1);

        return zSetOperations.count(key, tts+1, Long.MAX_VALUE);
    }

    /**
     * 删除一整个policyCache
     * @param zsetKey
     */
    public void removeCache(String zsetKey){
        redisTemplate.delete(zsetKey);
    }

    /**
     * 缓存清理者
     */
    @SuppressWarnings("unchecked")
    public void cacheCleaner(){
        Cache<String, InstantPolicy> cache = SpringContextUtil.getBean("policyCache", Cache.class);
        if (cache==null || cache.getAll().isEmpty()) {
            return;
        }

        for (InstantPolicy policy : cache.getAll().values()) {
            String keyPref = policy.buildKeyPref();

            Set<String> policyCacheKeys = redisTemplate.keys(keyPref);
            if (policyCacheKeys==null || policyCacheKeys.isEmpty()) {
                return;
            }

            //移除过期数据
            long now = System.currentTimeMillis();
            long tts = now - policy.getDuration() * 1000;
            for (String key : policyCacheKeys) {
                zSetOperations.removeRangeByScore(key, 0, tts);
            }
        }
    }

    private class Serializer implements RedisSerializer<String> {
        public byte[] serialize(String s) {
            if (s == null) {
                return null;
            }
            return s.getBytes();
        }

        public String deserialize(byte[] bytes) {
            if (bytes == null) {
                return null;
            }
            return new String(bytes);
        }
    }

    private class EventSerializer implements RedisSerializer<Event> {
        public byte[] serialize(Event event) {
            if (event == null) {
                return null;
            }
            return JSONObject.toJSONBytes(event);
        }

        public Event deserialize(byte[] bytes) {
            if (bytes == null) {
                return null;
            }
            return JSONObject.parseObject(bytes, Event.class);
        }
    }
}

---

附:
sorted set学习资料

http://www.cnblogs.com/stephen-liu74/archive/2012/03/23/2354994.html

http://doc.redisfans.com/sorted_set/zrangebyscore.html