Redis中SortedSet一些简单的API操作（JAVA）

接口

public interface IRedisService {
/**
     * SortSet add
     *
     * @param key
     * @param value
     * @param score
     * @return
     */
    public boolean zadd(String key, String value, double score);

    /**
     * SortSet add
     *
     * @param key
     * @param tupleSet
     * @return 添加到有序集合的成员数量
     */
    public long zadd(String key, Set<ZSetOperations.TypedTuple<String>> tupleSet);

    /**
     * 返回key的有序集元素个数 O(1)
     *
     * @param key
     * @return
     */
    public long zcard(String key);

    /**
     * 返回有序集key中，score值在min和max之间(默认包括score值等于min或max)的成员。O(log(N))
     *
     * @param key
     * @param minScore
     * @param maxScore
     * @return
     */
    public long zcount(String key, double minScore, double maxScore);

    /**
     * 为有序集key的成员member的score值加上增量increment。
     * 如果key中不存在member，就在key中添加一个member，score是increment（就好像它之前的score是0.0）。
     * 如果key不存在，就创建一个只含有指定member成员的有序集合。
     * 当key不是有序集类型时，返回一个错误。
     * O(log(N))
     * score值必须是字符串表示的整数值或双精度浮点数，并且能接受double精度的浮点数。也有可能给一个负数来减少score的值。
     *
     * @param key
     * @param value
     * @param incrScore
     * @return member成员的新score值
     */
    public double zincrby(String key, String value, double incrScore);

    /**
     * 返回存储在有序集合key中的指定范围的元素。 返回的元素可以认为是按得分从最低到最高排列。 如果得分相同，将按字典排序
     * 参数start和stop都是基于零的索引，即0是第一个元素，1是第二个元素，以此类推。
     * 它们也可以是负数，表示从有序集合的末尾的偏移量，其中-1是有序集合的最后一个元素，-2是倒数第二个元素，
     * start和stop都是全包含的区间
     * O(log(N)+M)
     *
     * @param key
     * @param startIndex
     * @param endIndex
     * @return 给定范围内的元素列表
     */
    public Set<String> zrange(String key, long startIndex, long endIndex);

    /**
     * 返回存储在有序集合key中的指定范围的元素。 返回的元素可以认为是按得分从最低到最高排列。 如果得分相同，将按字典排序
     * 参数start和stop都是基于零的索引，即0是第一个元素，1是第二个元素，以此类推。
     * 它们也可以是负数，表示从有序集合的末尾的偏移量，其中-1是有序集合的最后一个元素，-2是倒数第二个元素，
     * start和stop都是全包含的区间
     * O(log(N)+M)
     *
     * @param key
     * @param startIndex
     * @param endIndex
     * @return 给定范围内的元素列表，将同时返回它们的得分
     */
    public Set<ZSetOperations.TypedTuple<String>> zrangeWithScores(String key, long startIndex, long endIndex);

    /**
     * 返回key的有序集合中的分数在min和max之间的所有元素（包括分数等于max或者min的元素）。元素被认为是从低分到高分排序的。
     * 具有相同分数的元素按字典序排列（这个根据redis对有序集合实现的情况而定，并不需要进一步计算）。
     * O(log(N))
     *
     * @param key
     * @param startSocre
     * @param endScore
     * @return 给定范围内的元素列表
     */
    public Set<String> zrangeByScore(String key, double startSocre, double endScore);


    /**
     * 返回key的有序集合中的分数在min和max之间的所有元素（包括分数等于max或者min的元素）。元素被认为是从低分到高分排序的。
     * 具有相同分数的元素按字典序排列（这个根据redis对有序集合实现的情况而定，并不需要进一步计算）。
     * O(log(N))
     *
     * @param key
     * @param startSocre
     * @param endScore
     * @param offset
     * @param count
     * @return 给定范围内的元素列表
     */
    public Set<String> zrangeByScore(String key, double startSocre, double endScore, long offset, long count);


    /**
     * 返回key的有序集合中的分数在min和max之间的所有元素（包括分数等于max或者min的元素）。元素被认为是从低分到高分排序的。
     * 具有相同分数的元素按字典序排列（这个根据redis对有序集合实现的情况而定，并不需要进一步计算）。
     * O(log(N))+M
     *
     * @param key
     * @param startSocre
     * @param endScore
     * @return 给定范围内的元素列表，将同时返回它们的得分
     */
    public Set<ZSetOperations.TypedTuple<String>> zrangeWithScores(String key, double startSocre, double endScore);

    /**
     * 返回key的有序集合中的分数在min和max之间的所有元素（包括分数等于max或者min的元素）。元素被认为是从低分到高分排序的。
     * 具有相同分数的元素按字典序排列（这个根据redis对有序集合实现的情况而定，并不需要进一步计算）。
     * O(log(N))+M
     *
     * @param key
     * @param startSocre
     * @param endScore
     * @param offset
     * @param count
     * @return 给定范围内的元素列表，将同时返回它们的得分
     */
    public Set<ZSetOperations.TypedTuple<String>> zrangeWithScores(String key, double startSocre, double endScore, long offset, long count);

    /**
     * 回有序集key中成员member的排名。其中有序集成员按score值递增(从小到大)顺序排列。排名以0为底，也就是说，score值最小的成员排名为0。
     * O(log(N))
     *
     * @param key
     * @param value
     * @return
     */
    public Long zrank(String key, String value);

    /**
     * 删除某些member
     *
     * @param key
     * @param value
     * @return 删除的数量
     */
    public long zremove(String key, String... value);

    /**
     * 移除有序集key中，所有score值介于min和max之间(包括等于min或max)的成员
     *
     * @param key
     * @param startSocre
     * @param endScore
     * @return 删除的元素的个数。
     */
    public long zremoveRangeByScore(String key, double startSocre, double endScore);

    /**
     * 返回有序集key中，成员member的score值。
     * 如果member元素不是有序集key的成员，或key不存在，返回null。
     *
     * @param key
     * @param value
     * @return
     */
    public Double zscore(String key, String value);
}

2.实现

public class RedisServiceImpl implements IRedisService {
    protected static Logger logger = LoggerFactory.getLogger(RedisServiceImpl.class);
     @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Override
    public boolean zadd(String key, String value, double score) {
        boolean result = true;
        try {
            stringRedisTemplate.opsForZSet().add(key, value, score);
        } catch (Exception e) {
            logger.warn("zadd {}", key, e);
            result = false;
        }
        return result;
    }

    @Override
    public long zadd(String key, Set<ZSetOperations.TypedTuple<String>> tupleSet) {
        long result = 0;
        try {
            result = stringRedisTemplate.opsForZSet().add(key, tupleSet);
        } catch (Exception e) {
            logger.warn("zadd {}", key, e);
        }
        return result;
    }

    @Override
    public long zcard(String key) {
        long result = 0;
        try {
            result = stringRedisTemplate.opsForZSet().zCard(key);
        } catch (Exception e) {
            logger.warn("zcard {}", key, e);
        }
        return result;
    }

    @Override
    public long zcount(String key, double minScore, double maxScore) {
        long result = 0;
        try {
            result = stringRedisTemplate.opsForZSet().count(key, minScore, maxScore);
        } catch (Exception e) {
            logger.warn("zcount {}", key, e);
        }
        return result;
    }

    @Override
    public double zincrby(String key, String value, double incrScore) {
        double result = 0.00;

        try {
            result = stringRedisTemplate.opsForZSet().incrementScore(key, value, incrScore);
        } catch (Exception e) {
            logger.warn("zincrby {}", key, e);
        }
        return result;
    }

    @Override
    public Set<String> zrange(String key, long startIndex, long endIndex) {
        Set<String> set = null;
        try {
            set = stringRedisTemplate.opsForZSet().range(key, startIndex, endIndex);
        } catch (Exception e) {
            logger.warn("zincrby {}", key, e);
        }
        return set;
    }

    @Override
    public Set<ZSetOperations.TypedTuple<String>> zrangeWithScores(String key, long startIndex, long endIndex) {
        Set<ZSetOperations.TypedTuple<String>> set = null;
        try {
            set = stringRedisTemplate.opsForZSet().rangeWithScores(key, startIndex, endIndex);
        } catch (Exception e) {
            logger.warn("zrangeWithScores {}", key, e);
        }
        return set;
    }

    @Override
    public Set<String> zrangeByScore(String key, double startSocre, double endScore) {
        Set<String> set = null;
        try {
            set = stringRedisTemplate.opsForZSet().rangeByScore(key, startSocre, endScore);
        } catch (Exception e) {
            logger.warn("zrangeByScore {}", key, e);
        }
        return set;
    }

    @Override
    public Set<String> zrangeByScore(String key, double startSocre, double endScore, long offset, long count) {
        Set<String> set = null;
        try {
            set = stringRedisTemplate.opsForZSet().rangeByScore(key, startSocre, endScore, offset, count);
        } catch (Exception e) {
            logger.warn("zrangeByScore {}", key, e);
        }
        return set;
    }

    @Override
    public Set<ZSetOperations.TypedTuple<String>> zrangeWithScores(String key, double startSocre, double endScore) {
        Set<ZSetOperations.TypedTuple<String>> set = null;
        try {
            set = stringRedisTemplate.opsForZSet().rangeByScoreWithScores(key, startSocre, endScore);
        } catch (Exception e) {
            logger.warn("zrangeWithScores {}", key, e);
        }
        return set;
    }

    @Override
    public Set<ZSetOperations.TypedTuple<String>> zrangeWithScores(String key, double startSocre, double endScore, long offset, long count) {
        Set<ZSetOperations.TypedTuple<String>> set = null;

        try {
            set = stringRedisTemplate.opsForZSet().rangeByScoreWithScores(key, startSocre, endScore, offset, count);
        } catch (Exception e) {
            logger.warn("zrangeWithScores {}", key, e);
        }
        return set;
    }

    @Override
    public Long zrank(String key, String value) {
        Long result = null;
        try {
            result = stringRedisTemplate.opsForZSet().rank(key, value);
        } catch (Exception e) {
            logger.warn("zrank {}", key, e);
        }
        return result;
    }

    @Override
    public long zremove(String key, String... value) {
        long result = 0;
        try {
            result = stringRedisTemplate.opsForZSet().remove(key, value);
        } catch (Exception e) {
            logger.warn("zremove {}", key, e);
        }
        return result;
    }

    @Override
    public long zremoveRangeByScore(String key, double startSocre, double endScore) {
        long result = 0;
        try {
            result = stringRedisTemplate.opsForZSet().removeRangeByScore(key, startSocre, endScore);
        } catch (Exception e) {
            logger.warn("zremoveRangeByScore {}", key, e);
        }
        return result;
    }

    @Override
    public Double zscore(String key, String value) {
        Double result = null;
        try {
            result = stringRedisTemplate.opsForZSet().score(key, value);
        } catch (Exception e) {
            logger.warn("zscore {}", key, e);
        }
        return result;
    }
}