SpringCloud工作笔记070---SpringCloud中使用Redis存储List类型数据

版权声明：本文为博主原创文章，未经博主credreamer 允许不得转载 违者追究法律责任。 https://blog.csdn.net/lidew521/article/details/84947987

    JAVA技术交流QQ群：170933152  

看看这边封装的redis的工具类:

src\main\java\cn\gov\majorproj\scadmin\util\CacheUtils.java

注意,就是用下面的saveList,getList 这两个方法来实现的,直接存的时候存一个key,然后把obj转为json,通过json来进行中间过程

的存储,这样就可以了.

用法就是下面这样用,然后再下面是工具类:

package cn.gov.majorproj.scpermission.util;

import cn.gov.majorproj.scpermission.dao.SysAccessMapper;
import cn.gov.majorproj.scpermission.dao.SysRoleaccessMapper;
import cn.gov.majorproj.scpermission.model.SysAccess;
import cn.gov.majorproj.scpermission.model.SysRoleaccess;
import com.sun.javaws.CacheUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service("PermissionMemUtil")
public class PermissionMemUtil {
    @Autowired
    private SysRoleaccessMapper roleaccessMapper;
    @Autowired
    private SysAccessMapper accessMapper;

    private Logger logger=LoggerFactory.getLogger(this.getClass());

    public static List<SysRoleaccess> roleaccessesmap = new ArrayList<SysRoleaccess>();
    public static List<SysAccess> accessesmap = new ArrayList<SysAccess>();

    public static int flag = 1;

    public void refresh()
    {
        roleaccessesmap.clear();
        if (roleaccessesmap.isEmpty() && (flag == 1))
        {
            roleaccessesmap = roleaccessMapper.selectAll();
            CacheUtils.saveBean("roleaccessesmap",roleaccessesmap);
            roleaccessesmap.clear();
            roleaccessesmap=CacheUtils.getList("roleaccessesmap",SysRoleaccess.class);
        }
        else if (flag != 1)
        {
            logger.info("刷新数据字典操作~~~~~start");
            roleaccessesmap = roleaccessMapper.selectAll();
            CacheUtils.saveBean("roleaccessesmap",roleaccessesmap);
            roleaccessesmap.clear();
            roleaccessesmap=CacheUtils.getList("roleaccessesmap",SysRoleaccess.class);
        }
        logger.info("标识符:{},获取字典组数据:{}",flag,roleaccessesmap);

        //权限列表
        accessesmap.clear();
        if (accessesmap.isEmpty() && (flag == 1))
        {
            accessesmap = accessMapper.selectAll();
            CacheUtils.saveBean("accessesmap",accessesmap);
            accessesmap.clear();
            accessesmap=CacheUtils.getList("accessesmap",SysAccess.class);

        }
        else if (flag != 1)
        {
            logger.info("刷新数据字典操作~~~~~start");
            accessesmap = accessMapper.selectAll();
            CacheUtils.saveBean("accessesmap",accessesmap);
            accessesmap.clear();
            accessesmap=CacheUtils.getList("accessesmap",SysAccess.class);
        }
        logger.info("标识符:{},获取字典组数据:{}",flag,accessesmap);
    }

    /**
     * 根据角色id获取该角色拥有的角色权限信息
     * @param roleid 角色id
     * @return 角色权限列表
     */
    public static List<SysRoleaccess> getRoleaccessListByRoleId(String roleid)
    {
        List<SysRoleaccess> list=null;
        if (CmUtil.isNotEmpty(roleid) && !roleaccessesmap.isEmpty())
        {
            Integer introleid=Integer.valueOf(roleid);
            list = new ArrayList<SysRoleaccess>();
            for (SysRoleaccess dict: roleaccessesmap)
            {
                if (introleid.equals(dict.getRoleId()))
                {
                    list.add(dict);
                }
            }
            return list;
        }
        return PermissionMemUtil.roleaccessesmap;
    }

    /**
     *返回权限id对应的权限
     * @param accessId 权限id
     * @return 该权限id对应的权限
     */
    public static SysAccess getSysAccessByAccessId(Integer accessId)
    {
        if (CmUtil.isNotEmpty(accessId) && !accessesmap.isEmpty())
        {
            for (SysAccess dict: accessesmap)
            {
                if (accessId.equals(dict.getAccessId()))
                {
                    return dict;
                }
            }
        }
        return null;
    }

}

package cn.gov.majorproj.scpermission.util;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.Feature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.connection.RedisZSetCommands.Tuple;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * 描述: 操作redis 工具类
 * author: lidewei
 * Date: 2018/09/19 15:01
 */
@Component
public class CacheUtils {
    @Resource
    private RedisTemplate<String, String> redisTemplate;

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    private static CacheUtils cacheUtils;

    private static final Logger logger = LoggerFactory.getLogger(CacheUtils.class);

    @PostConstruct
    public void init() {
        cacheUtils = this;
        cacheUtils.redisTemplate = this.redisTemplate;
    }

    /**
     * 获取所有登录的用户
     *
     * @return
     */
    public static Integer getOnlineUsers() {
        Integer userCount = 0;
        userCount = cacheUtils.redisTemplate.keys("*").size();
        return userCount;
    }


    /**
     * 将数据存入缓存
     *
     * @param key
     * @param val
     * @return
     */
    public static void saveString(String key, String val) {

        ValueOperations<String, String> vo = cacheUtils.redisTemplate.opsForValue();
        vo.set(key, val);
    }

    /**
     * 将数据存入缓存的集合中
     *
     * @param key
     * @param val
     * @return
     */
    public static void saveToSet(String key, String val) {

        SetOperations<String, String> so = cacheUtils.redisTemplate.opsForSet();

        so.add(key, val);
    }

    /**
     * key 缓存Key
     *
     * @param key
     * @return
     */
    public static String getFromSet(String key) {
        return cacheUtils.redisTemplate.opsForSet().pop(key);
    }

    /**
     * 将 key的值保存为 value ，当且仅当 key 不存在。 若给定的 key 已经存在，则 SETNX 不做任何动作。 SETNX 是『SET if
     * Not eXists』(如果不存在，则 SET)的简写。 <br>
     * 保存成功，返回 true <br>
     * 保存失败，返回 false
     */
    public static boolean saveNX(String key, String val) {

        /** 设置成功，返回 1 设置失败，返回 0 **/
        return cacheUtils.redisTemplate.execute((RedisCallback<Boolean>) connection -> {
            return connection.setNX(key.getBytes(), val.getBytes());
        });

    }

    /**
     * 将 key的值保存为 value ，当且仅当 key 不存在。 若给定的 key 已经存在，则 SETNX 不做任何动作。 SETNX 是『SET if
     * Not eXists』(如果不存在，则 SET)的简写。 <br>
     * 保存成功，返回 true <br>
     * 保存失败，返回 false
     *
     * @param key
     * @param val
     * @param expire 超时时间
     * @return 保存成功，返回 true 否则返回 false
     */
    public static boolean saveNX(String key, String val, int expire) {

        boolean ret = saveNX(key, val);
        if (ret) {
            cacheUtils.redisTemplate.expire(key, expire, TimeUnit.SECONDS);
        }
        return ret;
    }

    /**
     * 将数据存入缓存（并设置失效时间）
     *
     * @param key
     * @param val
     * @param seconds
     * @return
     */
    public static void saveString(String key, String val, int seconds) {

        cacheUtils.redisTemplate.opsForValue().set(key, val, seconds, TimeUnit.SECONDS);
    }

    /**
     * 将自增变量存入缓存
     */
    public static void saveSeq(String key, long seqNo) {

        cacheUtils.redisTemplate.delete(key);
        cacheUtils.redisTemplate.opsForValue().increment(key, seqNo);
    }

    /**
     * 将递增浮点数存入缓存
     */
    public static void saveFloat(String key, float data) {

        cacheUtils.redisTemplate.delete(key);
        cacheUtils.redisTemplate.opsForValue().increment(key, data);
    }

    /**
     * 保存复杂类型数据到缓存
     *
     * @param key
     * @param obj
     * @return
     */
    public static void saveBean(String key, Object obj) {

        cacheUtils.redisTemplate.opsForValue().set(key, JSON.toJSONString(obj));
    }

    /**
     * 保存复杂类型LIST数据到缓存
     *
     * @param key
     * @param obj
     * @return
     */
    public static void saveList(String key, Object obj) {

        cacheUtils.redisTemplate.opsForValue().set(key, JSON.toJSONString(obj));
    }

    /**
     * 保存复杂类型数据到缓存（并设置失效时间）
     *
     * @param key
     * @param obj
     * @param seconds
     */
    public static void saveBean(String key, Object obj, int seconds) {

        cacheUtils.redisTemplate.opsForValue().set(key, JSON.toJSONString(obj), seconds, TimeUnit.SECONDS);
    }

    /**
     * 存到指定的队列中
     *
     * @param key
     * @param val
     * @param size
     */
    public static void saveToQueue(String key, String val, long size) {

        ListOperations<String, String> lo = cacheUtils.redisTemplate.opsForList();

        if (size > 0 && lo.size(key) >= size) {
            lo.rightPop(key);
        }
        lo.leftPush(key, val);
    }

    /**
     * 保存到hash集合中
     *
     * @param hName 集合名
     * @param key
     * @param value
     */
    public static void hashSet(String hName, String key, String value) {

        cacheUtils.redisTemplate.opsForHash().put(hName, key, value);
    }

    /**
     * 根据key获取所以值
     *
     * @param key
     * @return
     */
    public static Map<Object, Object> hgetAll(String key) {

        return cacheUtils.redisTemplate.opsForHash().entries(key);
    }

    /**
     * 保存到hash集合中
     *
     * @param <T>
     * @param hName 集合名
     * @param key
     * @param t
     */
    public static <T> void hashSet(String hName, String key, T t) {

        hashSet(hName, key, JSON.toJSONString(t));
    }

    /**
     * 取得复杂JSON数据
     *
     * @param key
     * @param clazz
     * @param clazz
     * @return
     */
    public static <T> T getBean(String key, Class<T> clazz) {

        String value = cacheUtils.redisTemplate.opsForValue().get(key);
        if (value == null) {
            return null;
        }
        return JSON.parseObject(value, clazz);
    }

    /**
     * 取得复杂JSON数据
     *
     * @param key
     * @param clazz
     * @return
     */
    public static <T> List<T> getList(String key, Class<T> clazz) {

        String value = cacheUtils.redisTemplate.opsForValue().get(key);
        if (value == null) {
            return null;
        }
        return JSON.parseArray(value, clazz);
    }

    /**
     * 从缓存中取得字符串数据
     *
     * @param key
     * @return 数据
     */
    public static String getString(String key) {
        cacheUtils.redisTemplate.opsForValue().get(key);

        return cacheUtils.redisTemplate.opsForValue().get(key);
    }

    /**
     * 从指定队列里取得数据
     *
     * @param key
     * @param size
     * @return
     */
    public static List<String> getFromQueue(String key, long size) {

        boolean flag = cacheUtils.redisTemplate.execute((RedisCallback<Boolean>) connection -> {
            return connection.exists(key.getBytes());
        });

        if (flag) {
            return new ArrayList<>();
        }
        ListOperations<String, String> lo = cacheUtils.redisTemplate.opsForList();
        if (size > 0) {
            return lo.range(key, 0, size - 1);
        } else {
            return lo.range(key, 0, lo.size(key) - 1);
        }
    }

    /**
     * 从指定队列里取得数据
     *
     * @param key
     * @return
     */
    public static String popQueue(String key) {

        return cacheUtils.redisTemplate.opsForList().rightPop(key);

    }

    /**
     * 取得序列值的下一个
     *
     * @param key
     * @return
     */
    public static Long getSeqNext(String key) {

        return cacheUtils.redisTemplate.execute((RedisCallback<Long>) connection -> {

            return connection.incr(key.getBytes());

        });
    }

    /**
     * 取得序列值的下一个
     *
     * @param key
     * @return
     */
    public static Long getSeqNext(String key, long value) {

        return cacheUtils.redisTemplate.execute((RedisCallback<Long>) connection -> {

            return connection.incrBy(key.getBytes(), value);

        });

    }

    /**
     * 将序列值回退一个
     *
     * @param key
     * @return
     */
    public static void getSeqBack(String key) {

        cacheUtils.redisTemplate.execute((RedisCallback<Long>) connection -> connection.decr(key.getBytes()));

    }

    /**
     * 从hash集合里取得
     *
     * @param hName
     * @param key
     * @return
     */
    public static Object hashGet(String hName, String key) {

        return cacheUtils.redisTemplate.opsForHash().get(hName, key);
    }

    public static <T> T hashGet(String hName, String key, Class<T> clazz) {

        return JSON.parseObject((String) hashGet(hName, key), clazz);
    }

    /**
     * 增加浮点数的值
     *
     * @param key
     * @return
     */
    public static Double incrFloat(String key, double incrBy) {

        return cacheUtils.redisTemplate.execute((RedisCallback<Double>) connection -> {

            return connection.incrBy(key.getBytes(), incrBy);

        });
    }

    /**
     * 判断是否缓存了数据
     *
     * @param key 数据KEY
     * @return 判断是否缓存了
     */
    public static boolean isCached(String key) {

        return cacheUtils.redisTemplate.execute((RedisCallback<Boolean>) connection -> {
            return connection.exists(key.getBytes());
        });
    }

    /**
     * 判断hash集合中是否缓存了数据
     *
     * @param hName
     * @param key   数据KEY
     * @return 判断是否缓存了
     */
    public static boolean hashCached(String hName, String key) {

        return cacheUtils.redisTemplate.execute((RedisCallback<Boolean>) connection -> {
            return connection.hExists(key.getBytes(), key.getBytes());
        });
    }

    /**
     * 判断是否缓存在指定的集合中
     *
     * @param key 数据KEY
     * @param val 数据
     * @return 判断是否缓存了
     */
    public static boolean isMember(String key, String val) {

        return cacheUtils.redisTemplate.execute((RedisCallback<Boolean>) connection -> {
            return connection.sIsMember(key.getBytes(), val.getBytes());
        });
    }

    /**
     * 从缓存中删除数据
     *
     * @param key
     * @return
     */
    public static void delKey(String key) {

        cacheUtils.redisTemplate.execute((RedisCallback<Long>) connection -> connection.del(key.getBytes()));
    }

    /**
     * 设置超时时间
     *
     * @param key
     * @param seconds
     */
    public static void expire(String key, int seconds) {
        cacheUtils.redisTemplate
                .execute((RedisCallback<Boolean>) connection -> connection.expire(key.getBytes(), seconds));

    }

    /**
     * 列出set中所有成员
     *
     * @param setName set名
     * @return
     */
    public static Set<Object> listSet(String setName) {

        return cacheUtils.redisTemplate.opsForHash().keys(setName);

    }

    /**
     * 向set中追加一个值
     *
     * @param setName set名
     * @param value
     */
    public static void setSave(String setName, String value) {

        cacheUtils.redisTemplate
                .execute((RedisCallback<Long>) connection -> connection.sAdd(setName.getBytes(), value.getBytes()));

    }

    /**
     * 逆序列出sorted set包括分数的set列表
     *
     * @param key   set名
     * @param start 开始位置
     * @param end   结束位置
     * @return 列表
     */
    public static Set<Tuple> listSortedsetRev(String key, int start, int end) {

        return cacheUtils.redisTemplate.execute((RedisCallback<Set<Tuple>>) connection -> {
            return connection.zRevRangeWithScores(key.getBytes(), start, end);
        });
    }

    /**
     * 逆序取得sorted sort排名
     *
     * @param key    set名
     * @param member 成员名
     * @return 排名
     */
    public static Long getRankRev(String key, String member) {

        return cacheUtils.redisTemplate.execute((RedisCallback<Long>) connection -> {
            return connection.zRevRank(key.getBytes(), member.getBytes());
        });

    }

    /**
     * 根据成员名取得sorted sort分数
     *
     * @param key    set名
     * @param member 成员名
     * @return 分数
     */
    public static Double getMemberScore(String key, String member) {

        return cacheUtils.redisTemplate.execute((RedisCallback<Double>) connection -> {
            return connection.zScore(key.getBytes(), member.getBytes());
        });
    }

    /**
     * 向sorted set中追加一个值
     *
     * @param key    set名
     * @param score  分数
     * @param member 成员名称
     */
    public static void saveToSortedset(String key, Double score, String member) {

        cacheUtils.redisTemplate.execute(
                (RedisCallback<Boolean>) connection -> connection.zAdd(key.getBytes(), score, member.getBytes()));
    }

    /**
     * 从sorted set删除一个值
     *
     * @param key    set名
     * @param member 成员名称
     */
    public static void delFromSortedset(String key, String member) {
        cacheUtils.redisTemplate
                .execute((RedisCallback<Long>) connection -> connection.zRem(key.getBytes(), member.getBytes()));

    }

    /**
     * 从hash map中取得复杂JSON数据
     *
     * @param key
     * @param field
     * @param clazz
     */
    public static <T> T getBeanFromMap(String key, String field, Class<T> clazz) {

        byte[] input = cacheUtils.redisTemplate.execute((RedisCallback<byte[]>) connection -> {
            return connection.hGet(key.getBytes(), field.getBytes());
        });
        return JSON.parseObject(input, clazz, Feature.AutoCloseSource);
    }

    /**
     * 从hashmap中删除一个值
     *
     * @param key   map名
     * @param field 成员名称
     */
    public static void delFromMap(String key, String field) {

        cacheUtils.redisTemplate
                .execute((RedisCallback<Long>) connection -> connection.hDel(key.getBytes(), field.getBytes()));

    }

    /**
     * @param key
     * @return
     * @Description: 根据key增长 ，计数器
     * @author clg
     * @date 2016年6月30日 下午2:37:52
     */
    public static long incr(String key) {

        return cacheUtils.redisTemplate.execute((RedisCallback<Long>) connection -> {
            return connection.incr(key.getBytes());
        });
    }


    /**
     * 根据key获取当前计数结果
     *
     * @param key
     * @return
     */
    public static String getCount(String key) {

        return cacheUtils.redisTemplate.opsForValue().get(key);
    }

    /**
     * 将所有指定的值插入到存于 key 的列表的头部。如果 key 不存在，那么在进行 push 操作前会创建一个空列表
     *
     * @param <T>
     * @param key
     * @param value
     * @return
     */
    public static <T> Long lpush(String key, T value) {

        return cacheUtils.redisTemplate.opsForList().leftPush(key, JSON.toJSONString(value));
    }

    /**
     * 只有当 key 已经存在并且存着一个 list 的时候，在这个 key 下面的 list 的头部插入 value。 与 LPUSH 相反，当 key
     * 不存在的时候不会进行任何操作
     *
     * @param key
     * @param value
     * @return
     */
    public static <T> Long lpushx(String key, T value) {

        return cacheUtils.redisTemplate.opsForList().leftPushIfPresent(key, JSON.toJSONString(value));
    }

    /**
     * 返回存储在 key 里的list的长度。 如果 key 不存在，那么就被看作是空list，并且返回长度为 0
     *
     * @param key
     * @return
     */
    public static Long llen(String key) {

        return cacheUtils.redisTemplate.opsForList().size(key);
    }

    /**
     * 返回存储在 key 的列表里指定范围内的元素。 start 和 end
     * 偏移量都是基于0的下标，即list的第一个元素下标是0（list的表头），第二个元素下标是1，以此类推
     *
     * @param key
     * @return
     */
    public static List<String> lrange(String key, long start, long end) {

        return cacheUtils.redisTemplate.opsForList().range(key, start, end);
    }

    /**
     * 移除并且返回 key 对应的 list 的第一个元素
     *
     * @param key
     * @return
     */
    public static String lpop(String key) {

        return cacheUtils.redisTemplate.opsForList().leftPop(key);
    }

    /**
     * 保存到hash集合中 只在 key 指定的哈希集中不存在指定的字段时，设置字段的值。如果 key 指定的哈希集不存在，会创建一个新的哈希集并与 key
     * 关联。如果字段已存在，该操作无效果。
     *
     * @param hName 集合名
     * @param key
     * @param value
     */
    public static void hsetnx(String hName, String key, String value) {

        cacheUtils.redisTemplate.execute((RedisCallback<Boolean>) connection -> connection.hSetNX(key.getBytes(),
                key.getBytes(), value.getBytes()));

    }

    /**
     * 保存到hash集合中 只在 key 指定的哈希集中不存在指定的字段时，设置字段的值。如果 key 指定的哈希集不存在，会创建一个新的哈希集并与 key
     * 关联。如果字段已存在，该操作无效果。
     *
     * @param hName 集合名
     * @param key
     * @param t
     * @param <T>
     */
    public static <T> void hsetnx(String hName, String key, T t) {
        hsetnx(hName, key, JSON.toJSONString(t));
    }


}