SpringBoot中操作spring redis的工具类

阳光穿透心脏的1/2处 2023-10-05 09:26 56阅读 0赞

## 场景 ##

SpringBoot+Vue+Redis实现前后端分离的字典缓存机制：

[https://blog.csdn.net/badao\_liumang\_qizhi/article/details/108333996][https_blog.csdn.net_badao_liumang_qizhi_article_details_108333996]

在SpringBoot后台中会使用到Redis去缓存一些数据。

Windows下Redis服务端的安装与配置

[https://blog.csdn.net/BADAO\_LIUMANG\_QIZHI/article/details/107486313][https_blog.csdn.net_BADAO_LIUMANG_QIZHI_article_details_107486313]

注：

博客：  
[https://blog.csdn.net/badao\_liumang\_qizhi][https_blog.csdn.net_badao_liumang_qizhi]  
关注公众号  
霸道的程序猿  
获取编程相关电子书、教程推送与免费下载。

## 实现 ##

首先pom文件中引入相关依赖。

<dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-data-redis</artifactId>
      </dependency>

然后在application.yml配置Redis服务端的连接

# Spring配置
    spring:
      # 资源信息
      messages:
        # 国际化资源文件路径
        basename: i18n/messages
      profiles:
        active: druid
      # 文件上传
      servlet:
         multipart:
           # 单个文件大小
           max-file-size:  10MB
           # 设置总上传的文件大小
           max-request-size:  20MB
      # 服务模块
      devtools:
        restart:
          # 热部署开关
          enabled: true
      # redis 配置
      redis:
        # 地址
        #本地测试用
        host: 127.0.0.1
        port: 6379
        password: 123456
        # 连接超时时间
        timeout: 10s
        lettuce:
          pool:
            # 连接池中的最小空闲连接
            min-idle: 0
            # 连接池中的最大空闲连接
            max-idle: 8
            # 连接池的最大数据库连接数
            max-active: 8
            # #连接池最大阻塞等待时间（使用负值表示没有限制）
            max-wait: -1ms

这里配置的Redis服务端是我自己的本地

然后封装一个Spring Redis的工具类 用来对Redis 进行缓存和获取数据等。

import java.util.ArrayList;
    import java.util.Collection;
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.concurrent.TimeUnit;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.BoundSetOperations;
    import org.springframework.data.redis.core.HashOperations;
    import org.springframework.data.redis.core.ListOperations;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.ValueOperations;
    import org.springframework.stereotype.Component;
    
    /**
     * spring redis 工具类
     *
     **/
    @SuppressWarnings(value = { "unchecked", "rawtypes" })
    @Component
    public class RedisCache
    {
        @Autowired
        public RedisTemplate redisTemplate;
    
        /**
         * 缓存基本的对象，Integer、String、实体类等
         *
         * @param key 缓存的键值
         * @param value 缓存的值
         * @return 缓存的对象
         */
        public <T> ValueOperations<String, T> setCacheObject(String key, T value)
        {
            ValueOperations<String, T> operation = redisTemplate.opsForValue();
            operation.set(key, value);
            return operation;
        }
    
        /**
         * 缓存基本的对象，Integer、String、实体类等
         *
         * @param key 缓存的键值
         * @param value 缓存的值
         * @param timeout 时间
         * @param timeUnit 时间颗粒度
         * @return 缓存的对象
         */
        public <T> ValueOperations<String, T> setCacheObject(String key, T value, Integer timeout, TimeUnit timeUnit)
        {
            ValueOperations<String, T> operation = redisTemplate.opsForValue();
            operation.set(key, value, timeout, timeUnit);
            return operation;
        }
    
        /**
         * 获得缓存的基本对象。
         *
         * @param key 缓存键值
         * @return 缓存键值对应的数据
         */
        public <T> T getCacheObject(String key)
        {
            ValueOperations<String, T> operation = redisTemplate.opsForValue();
            return operation.get(key);
        }
    
        /**
         * 删除单个对象
         *
         * @param key
         */
        public void deleteObject(String key)
        {
            redisTemplate.delete(key);
        }
    
        /**
         * 删除集合对象
         *
         * @param collection
         */
        public void deleteObject(Collection collection)
        {
            redisTemplate.delete(collection);
        }
    
        /**
         * 缓存List数据
         *
         * @param key 缓存的键值
         * @param dataList 待缓存的List数据
         * @return 缓存的对象
         */
        public <T> ListOperations<String, T> setCacheList(String key, List<T> dataList)
        {
            ListOperations listOperation = redisTemplate.opsForList();
            if (null != dataList)
            {
                int size = dataList.size();
                for (int i = 0; i < size; i++)
                {
                    listOperation.leftPush(key, dataList.get(i));
                }
            }
            return listOperation;
        }
    
        /**
         * 获得缓存的list对象
         *
         * @param key 缓存的键值
         * @return 缓存键值对应的数据
         */
        public <T> List<T> getCacheList(String key)
        {
            List<T> dataList = new ArrayList<T>();
            ListOperations<String, T> listOperation = redisTemplate.opsForList();
            Long size = listOperation.size(key);
    
            for (int i = 0; i < size; i++)
            {
                dataList.add(listOperation.index(key, i));
            }
            return dataList;
        }
    
        /**
         * 缓存Set
         *
         * @param key 缓存键值
         * @param dataSet 缓存的数据
         * @return 缓存数据的对象
         */
        public <T> BoundSetOperations<String, T> setCacheSet(String key, Set<T> dataSet)
        {
            BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
            Iterator<T> it = dataSet.iterator();
            while (it.hasNext())
            {
                setOperation.add(it.next());
            }
            return setOperation;
        }
    
        /**
         * 获得缓存的set
         *
         * @param key
         * @return
         */
        public <T> Set<T> getCacheSet(String key)
        {
            Set<T> dataSet = new HashSet<T>();
            BoundSetOperations<String, T> operation = redisTemplate.boundSetOps(key);
            dataSet = operation.members();
            return dataSet;
        }
    
        /**
         * 缓存Map
         *
         * @param key
         * @param dataMap
         * @return
         */
        public <T> HashOperations<String, String, T> setCacheMap(String key, Map<String, T> dataMap)
        {
            HashOperations hashOperations = redisTemplate.opsForHash();
            if (null != dataMap)
            {
                for (Map.Entry<String, T> entry : dataMap.entrySet())
                {
                    hashOperations.put(key, entry.getKey(), entry.getValue());
                }
            }
            return hashOperations;
        }
    
        /**
         * 获得缓存的Map
         *
         * @param key
         * @return
         */
        public <T> Map<String, T> getCacheMap(String key)
        {
            Map<String, T> map = redisTemplate.opsForHash().entries(key);
            return map;
        }
    
        /**
         * 获得缓存的基本对象列表
         *
         * @param pattern 字符串前缀
         * @return 对象列表
         */
        public Collection<String> keys(String pattern)
        {
            return redisTemplate.keys(pattern);
        }
    }

那么在进行设置数据缓存时

public static void setDictCache(String key, List<SysDictData> dictDatas)
        {
            SpringUtils.getBean(RedisCache.class).setCacheObject(key, dictDatas);
        }

这里的key就是设置的缓存的键，后面的对象的list就是要缓存的数据。

这里获取RedisCache的方式是通过

SpringUtils.getBean(RedisCache.class)

因为这是在一个不受spring管理的工具类中。

如果是在其他受spring管理的bean中的话直接通过注解获取RedisCache即可。

同理在获取缓存的数据时

Object cacheObj = SpringUtils.getBean(RedisCache.class).getCacheObject(getCacheKey(key));

同理其他工具类方法都可使用。

[https_blog.csdn.net_badao_liumang_qizhi_article_details_108333996]: https://blog.csdn.net/badao_liumang_qizhi/article/details/108333996
[https_blog.csdn.net_BADAO_LIUMANG_QIZHI_article_details_107486313]: https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/107486313
[https_blog.csdn.net_badao_liumang_qizhi]: https://blog.csdn.net/badao_liumang_qizhi