Redis分页缓存查询

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
<!--JSONObject、JSONArray 依赖 start-->
        <dependency>
            <groupId>commons-beanutils</groupId>
            <artifactId>commons-beanutils</artifactId>
            <version>1.9.3</version>
        </dependency>
        <dependency>
            <groupId>commons-collections</groupId>
            <artifactId>commons-collections</artifactId>
            <version>3.2.1</version>
        </dependency>
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.1.1</version>
        </dependency>
        <dependency>
            <groupId>net.sf.ezmorph</groupId>
            <artifactId>ezmorph</artifactId>
            <version>1.0.6</version>
        </dependency>
        <dependency>
            <groupId>net.sf.json-lib</groupId>
            <artifactId>json-lib</artifactId>
            <version>2.2.3</version>
            <classifier>jdk15</classifier><!-- jdk版本 -->
        </dependency>
        <!--JSONObject、JSONArray 依赖 end-->

import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import com.traffic.admin.common.utils.spring.SpringUtils;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
@AutoConfigureAfter(value = ApplicationConfig.class)
public class RedisConfig {

    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        ObjectMapper objectMapper = SpringUtils.getBean(ObjectMapper.class).copy();

        // 此项必须配置，否则会报java.lang.ClassCastException: java.util.LinkedHashMap cannot be cast to XXX
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);

        // 使用Jackson2JsonRedisSerialize 替换默认序列化
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        // 设置value的序列化规则和key的序列化规则
        redisTemplate.setKeySerializer(stringRedisSerializer);
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();

        return redisTemplate;
    }

}

import cn.hutool.core.lang.TypeReference;
import com.traffic.admin.common.constants.CacheConstants;
import com.traffic.admin.common.utils.core.ConvertUtils;
import com.traffic.admin.common.utils.spring.SpringUtils;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.util.Collection;
import java.util.List;
import java.util.Set;

@Component
public class RedisPageUtil {

    private final static RedisTemplate<Object, Object> redisTemplate;

    static {
        redisTemplate = ConvertUtils.convert(new TypeReference<RedisTemplate<Object, Object>>() {},
                SpringUtils.getBean(CacheConstants.REDIS_TEMPLATE_NAME, RedisTemplate.class));
    }


    /**
     * 创建 分页数据
     * @param zsetName zset名称
     * @param id 分值/id
     * @param str 需要返回的数据
     */
    public void addCach(String zsetName,  Long id,String str) {
        String hashName=zsetName+"Hash";
        //创建zset
        zSetAdd(zsetName,id,String.valueOf(id));
        //创建hash
        hSetAdd(hashName,String.valueOf(id),str);
    }
    /**
     * 获取分页数据
     * @param zsetName zset名称
     * @param pages 页数
     * @param size 每页条数
     * @param t 返回的对象
     * @return
     */
    public LayuiPageInfo getCachList(String zsetName,  Integer pages, Integer size, Object t){
        String hashName=zsetName+"Hash";
        //获取总条数
        long toal = zSetToal(zsetName);
        //总页数
        Long totalPage = setsearchCount(toal, Long.valueOf(size));
        //获取最大分值
        double maxScore = maxScore(zsetName);
        //获取zset的区间
        Set limit = zSetLimit(zsetName, 0, maxScore, (pages - 1) * size, size);
        //根据zset的区间获取 hash的集合
        List addHashComStore = hsetGetList(hashName, limit);
        net.sf.json.JSONArray jsonArray = net.sf.json.JSONArray.fromObject( addHashComStore);
        List list1 = (List) net.sf.json.JSONArray.toCollection(jsonArray,t.getClass());
        return LayuiPageInfo.createPageInfo(list1,Integer.valueOf(String.valueOf(toal)),Integer.valueOf(String.valueOf(totalPage)));
    }
    /**
     * 根据id 删除 zset 、hash中的数据
     * @param zsetName
     * @param id
     */
    public void delALl(String zsetName, Integer id){
        String hashName=zsetName+"Hash";
        zSetDel(zsetName,id);
        hSetdel(hashName,String.valueOf(id));
    }

    /**
     * Redis Zadd 命令用于将一个元素及其分数值加入到有序集当中。
     * @param name zset名称
     * @param score 分数
     * @param value 值
     */
    public void zSetAdd(String name,double score,String value){
        redisTemplate.opsForZSet().add(name,value,score);
    }

    /**
     * Zset 根据分值删除其中一个
     * @param name zset名称
     * @param score 分数
     */
    public void zSetDel(String name,double score){
        redisTemplate.opsForZSet().removeRangeByScore(name,score,score);
    }
    public Double maxScore(String name){
        Set<Object> sortId = redisTemplate.opsForZSet().reverseRange(name, 0, 0);
        if(sortId.size()==0){
            return 0d;
        }else {
            String hkey = String.valueOf(sortId.iterator().next());
            //根据member获得最大分值
            Double maxScore = redisTemplate.opsForZSet().score(name, hkey);
            return  maxScore;
        }

    }
    /**
     * zSet 获取总条数
     * @param name
     */
    public long zSetToal(String name){
        long count = redisTemplate.opsForZSet().zCard(name);
        return  count;
    }

    /**
     *  zSet 根据设置的score获取区间值从给定下标和给定长度获取最终值。
     * @param key
     * @param min
     * @param max
     * @param offset
     * @param count
     * @return
     */
    public Set zSetLimit(String key, double min, double max,long offset, long count){
        Set  zSetValue = redisTemplate.opsForZSet().rangeByScore(key, min, max, offset, count);
        return zSetValue;
    }

    /**
     * 哈希 新增hashMap值
     * @param key hset名称
     * @param hashKey key
     * @param value 值
     */
    public void hSetAdd(String key,String hashKey,String value){
        redisTemplate.opsForHash().put(key,hashKey,value);
    }

    /**
     * 哈希 根据hashKey 删除
     * @param key
     * @param hashKey
     */
    public void hSetdel(String key,String hashKey){
        redisTemplate.opsForHash().delete(key,hashKey);
    }

    public List hsetGetList(String key, Collection list){
        List mapValueList = redisTemplate.opsForHash().multiGet(key,list);
        return  mapValueList;
    }
    public static Long setsearchCount(Long searchCount,Long size) {
        //页数根据传入的总行数以及每页显示的行数，求出总页数
        return searchCount % size == 0 ? searchCount / size : (searchCount / size + 1);
    }

}

import com.fasterxml.jackson.annotation.JsonInclude;
import io.swagger.annotations.ApiModelProperty;

import java.util.List;
import java.util.Map;

@JsonInclude(JsonInclude.Include.NON_NULL)
public class LayuiPageInfo<T>    {

    private static Long size=20l; // 每页显示的行数，需要传参
    public static Long setsearchCount(Long searchCount) {
        //页数根据传入的总行数以及每页显示的行数，求出总页数
        return searchCount % size == 0 ? searchCount / size : (searchCount / size + 1);
    }

    @ApiModelProperty(value = "返回码", dataType = "String")
    private Integer code=0;
    @ApiModelProperty(value = "响应提示")
    private String msg   = "请求成功"; ;
    @ApiModelProperty(value ="数据")
    private List<T> data;
    @ApiModelProperty(value ="map")
    private Map<String,Object> totalRow;
    @ApiModelProperty(value ="object")
    public Object object;
    @ApiModelProperty(value ="count")
    private Integer count;
    @ApiModelProperty(value ="totalpages")
    private Integer totalpages;

    private String score;


    public String getScore() {
        return score;
    }

    public void setScore(String score) {
        this.score = score;
    }

    public void setResultStatus(Integer code, String msg ){
        this.code = code;
        this.msg = msg;
    }

    public Integer getCount() {
        return count;
    }

    public void setCount(Integer count) {
        this.count = count;
    }

    public Integer getTotalpages() {
        return totalpages;
    }

    public void setTotalpages(Integer totalpages) {
        this.totalpages = totalpages;
    }

    public Map<String, Object> getTotalRow() {
        return totalRow;
    }

    public void setTotalRow(Map<String, Object> totalRow) {
        this.totalRow = totalRow;
    }

    public List<T> getData() {
        return data;
    }

    public void setData(List<T> data) {
        this.data = data;
    }

    public Object getObject() {
        return object;
    }

    public void setObject(Object object) {
        this.object = object;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }


    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }


    public static LayuiPageInfo createPageInfo(List list, Integer count, Integer totalpages) {
        LayuiPageInfo result = new LayuiPageInfo();
        result.setCount(count);
        result.setTotalpages(totalpages);
        result.setData(list);
        return result;
    }


    public static LayuiPageInfo createPageInfoError(Integer code,String msg) {
        LayuiPageInfo result = new LayuiPageInfo();
        result.setCode(code);
        result.setMsg(msg);
        return result;
    }
}

import com.alibaba.fastjson.JSONObject;
import com.traffic.admin.business.person.ITrainingPersonService;
import com.traffic.admin.common.annotations.Anonymous;
import com.traffic.admin.common.page.TableData;
import com.traffic.admin.domain.dto.person.StudentQueryDto;
import com.traffic.admin.domain.vo.person.StudentQueryVo;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.validation.constraints.Min;

@Api(tags = "任务API")
@Slf4j
@RestController
@RequestMapping("/apitest/test")
@RequiredArgsConstructor(onConstructor_ = @Autowired)
public class TestAPI {


    private final RedisPageUtil redisPageUtils;
    private final ITrainingPersonService trainingPersonService;

    @ApiOperation(value = "删除 ")
    @RequestMapping(value = "/delt", method = RequestMethod.POST)
    @Anonymous
    public LayuiPageInfo  del(@RequestParam(value = "id")  Integer id ) {
        String zsetName="addZSETComStore";
        redisPageUtils.delALl(zsetName,id);
        return LayuiPageInfo.createPageInfoError(0,"ok");
    }

    @ApiOperation(value = "获取列表")
    @RequestMapping(value = "/getListt", method = RequestMethod.POST)
    @Anonymous
    public LayuiPageInfo<StudentQueryVo> getList(
            @RequestParam(value = "pages", defaultValue = "1") @Min(value = 1, message = "页数 不能为空") Integer pages) {
        int size = 5;
        String zsetName="addZSETComStore";
        LayuiPageInfo cachList = redisPageUtils.getCachList(zsetName,  pages, size, new StudentQueryVo());
        return cachList;
    }


    @ApiOperation(value = "list初始化")
    @RequestMapping(value = "/testt", method = RequestMethod.POST)
    @Anonymous
    public LayuiPageInfo  test(StudentQueryDto studentQueryDto) {
        String zsetName="addZSETComStore";
        TableData<StudentQueryVo> list = trainingPersonService.getStudentPage(studentQueryDto, true);
        for (StudentQueryVo admin : list.getRecords()) {
            redisPageUtils.addCach(zsetName,Long.valueOf(admin.getRowNo()), JSONObject.toJSONString(admin));
        }
        return LayuiPageInfo.createPageInfoError(0,"ok");
    }


}