redisson 实现分页存储与分页查询处理

声明：如果要转载请注明来自Garcia 

IPage是mybatis-plus 的分页代码 

com.baomidou.mybatisplus.core.metadata.IPage

    @Override
    public <K, V> Map<K,V> getMapEntryAll(String key, Set<K> entryKey) {
        try {
            RMap<K, V> rMap = redisson.getMap(wrap(key));
            return rMap.getAll(entryKey);
        }catch (Exception e){
            log.error("Method#getMapEntryAll failed",e);
            return null;
        }

    @Override
    public Integer getScoredSortedSetSize(String key) {
        RScoredSortedSet sortedSet = redisson.getScoredSortedSet(wrap(key));
        return sortedSet.size();
    }
 
    @Override
    public <V> void addScoredSortedSetElement(String key, V element) {
        redisson.getScoredSortedSet(wrap(key)).add(0,element);
    }
 
    @Override
    public <V> void addScoredSortedSetElement(String key, V element,double v) {
        redisson.getScoredSortedSet(wrap(key)).add(v,element);
    }
 
    @Override
    public <V> void addScoredSortedSetElement(String key, V element, int expireSeconds) {
        redisson.getScoredSortedSet(wrap(key)).add(0,element);
    }
 
    @Override
    public <V> void addScoredSortedSetElement(String key, V element,double v, int expireSeconds) {
        redisson.getScoredSortedSet(wrap(key)).add(v,element);
    }
 
    @Override
    public <V> Collection<V> getScoredSortedSetValueRangeReversed(String key,int startIndex, int endIndex) {
        try {
            RScoredSortedSet<V> rSet = redisson.getScoredSortedSet(wrap(key));
            return rSet.valueRangeReversed(startIndex,endIndex);
        }catch (Exception e){
            log.error("Method#getScoredSortedSetValueRangeReversed failed",e);
            return Collections.emptySet();
        }
    }
 
    @Override
    public <V> Collection<V> getScoredSortedSetValueRange(String key,int startIndex, int endIndex) {
        try {
            RScoredSortedSet<V> rSet = redisson.getScoredSortedSet(wrap(key));
            return rSet.valueRange(startIndex,endIndex);
        }catch (Exception e){
            log.error("Method#getScoredSortedSetValueRangeReversed failed",e);
            return Collections.emptySet();
        }
    }
 
    @Override
    public <V> Collection<ScoredEntry<V>> getScoredSortedSetEntryRangeReversed(String key,int startIndex, int endIndex) {
        try {
            RScoredSortedSet<V> rSet = redisson.getScoredSortedSet(wrap(key));
            return rSet.entryRangeReversed(startIndex,endIndex);
        }catch (Exception e){
            log.error("Method#getScoredSortedSetValueRangeReversed failed",e);
            return Collections.emptySet();
        }
    }
 
    @Override
    public <V> Collection<V> getScoredSortedSet(String key) {
        try {
            RScoredSortedSet<V> rSet = redisson.getScoredSortedSet(wrap(key));
            return rSet.readAll();
        }catch (Exception e){
            log.error("Method#getScoredSortedSet failed",e);
            return Collections.emptySet();
        }
    }
 
    @Override
    public <V> boolean hasScoredSortedSetElement(String key, V element) {
        try {
            return redisson.getSet(wrap(key)).contains(element);
        }catch (Exception e){
            log.error("Method#hasSetElement failed",e);
            return false;
        }
    }
 
    @Override
    public <V> boolean delScoredSortedSetElement(String key, V element) {
        return redisson.getSet(wrap(key)).remove(element);
    }
 
    @Override
    public <V> void addPageElement(String key,Long entryKey,V element){
        this.addScoredSortedSetElement(key,entryKey);
        this.addMapEntry(wrapEntry(key),entryKey,element);
    }
 
    @Override
    public void delPageElement(String key,Long entryKey){
        this.delScoredSortedSetElement(key,entryKey);
        this.delMapEntry(wrapEntry(key),entryKey);
    }
 
    @Override
    public <V> IPage<V> getPageElementDesc(String key,Integer pageCurrent,Integer pageSize){
        IPage<V> page = new Page<>(pageCurrent,pageSize);
        //总数
        Integer total = this.getScoredSortedSetSize(key);
        if (total!=null&&total>0){
            page.setTotal(total);
            if (page.getPages()<pageCurrent){
                //当前页码大于页码数直接返回空
                return page;
            }
            Integer startIndex = Integer.parseInt(String.valueOf(page.offset()));
            Integer endIndex = Integer.parseInt(String.valueOf(page.offset()))+pageSize-1;
            //分页条目
            Collection<Long> list = this.getScoredSortedSetValueRangeReversed(key,startIndex,endIndex);
            return getPage(key,page,list);
        }
        return page;
    }
 
    @Override
    public <V> IPage<V> getPageElement(String key,Integer pageCurrent,Integer pageSize){
        IPage<V> page = new Page<>(pageCurrent,pageSize);
        //总数
        Integer total = this.getScoredSortedSetSize(key);
        if (total!=null&&total>0){
            page.setTotal(total);
            if (page.getPages()<pageCurrent){
                //当前页码大于页码数直接返回空
                return page;
            }
            Integer startIndex = Integer.parseInt(String.valueOf(page.offset()));
            Integer endIndex = Integer.parseInt(String.valueOf(page.offset()))+pageSize-1;
            //分页条目
            Collection<Long> list = this.getScoredSortedSetValueRange(key,startIndex,endIndex);
            return getPage(key,page,list);
        }
        return page;
    }
 
    private <V> IPage<V> getPage(String key,IPage<V> page,Collection<Long> list){
        if (!CollectionUtils.isEmpty(list)){
            Set<Long> set = list.stream().collect(Collectors.toSet());
            Map<Long, V> masterMap = this.getMapEntryAll(wrapEntry(key),set);
            masterMap.forEach((id, master) -> page.getRecords().add(master));
            return page;
        }
        return page;
    }