springboot中集成redis，二次封装成工具类

Posted 2023-03-07 穆雄雄

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了springboot中集成redis，二次封装成工具类相关的知识，希望对你有一定的参考价值。

大家好，我是雄雄，欢迎关注微信公众号：** 雄雄的小课堂 **

现在是：2023年2月28日11:01:56

前言

redis大家应该都不陌生，我们在好多场景下都会使用，最近在面试别人的时候，也会问一些关于redis的问题，不多大家说的使用场景，基本都是在登录的时候，将用户信息放在缓存中，别的用的很少。表示一般在开发的时候，也不会进行二次封装redis的类，而是框架中本来就已经整合起来了，所以拿着用就行。

最近我在写一套开源的与社交软件交互的系统，后端采用的是springboot项目，有个地方需要用到缓存redis，所以就将原来的redis封装了下，现在分享出来。

springboot中集成redis

首先我们需要在pom文件中引入依赖，代码如下：

 <!-- 集成redis依赖  -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

在需要使用redis的类中，加入自动注入redis的代码：

  @Autowired
    private RedisTemplate redisTemplate;

然后接下来我们就可以使用redis了，比如我们想给缓存中放存一个对象，那么我们可以这样写：

  redisTemplate.opsForValue().set("name", "穆雄雄");

此时我们已经将name放在缓存中，那我们在使用的时候如何从缓存中获取呢？可以如下：

  return key == null ? null : redisTemplate.opsForValue().get(key);

包括批量添加key:

    Map<String, String> keyAndValue = new HashMap<String.String>();
     keyAndValue.put("name","穆雄雄");
    keyAndValue.put("age","20");
    redisTemplate.opsForValue().multiSet(keyAndValue);

如果在我们项目中使用redis的话，这样操作不仅繁琐，而且写起来也复杂，我们如何让在别的地儿使用的时候更加方便顺手呢，这个时候我们就需要做个简单的封装，

封装redis工具类

下面是我做了个简单的封装，部分也是参考的别人的：

给一个指定的 key 值附加过期时间

   public boolean expire(String key, long time) 
        return redisTemplate.expire(key, time, TimeUnit.SECONDS);

根据key 获取过期时间

 public long getTime(String key) 
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);

移除指定key 的过期时间

  public boolean persist(String key) 
        return redisTemplate.boundValueOps(key).persist();

根据key获取值

    public Object get(String key) 
        return key == null ? null : redisTemplate.opsForValue().get(key);

将值放入缓存

  public void set(String key, String value) 
        redisTemplate.opsForValue().set(key, value);

移除指定key 的过期时间

  public boolean persist(String key) 
        return redisTemplate.boundValueOps(key).persist();

将值放入缓存并设置时间

  public void set(String key, String value, long time) 
        if (time > 0) 
            redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
         else 
            redisTemplate.opsForValue().set(key, value);

批量添加 key (重复的键会覆盖)

  public void batchSet(Map<String, String> keyAndValue) 
        redisTemplate.opsForValue().multiSet(keyAndValue);

批量添加 key-value 只有在键不存在时,才添加,map 中只要有一个key存在,则全部不添加

  public void batchSetIfAbsent(Map<String, String> keyAndValue) 
        redisTemplate.opsForValue().multiSetIfAbsent(keyAndValue);

对一个 key-value 的值进行加减操作,如果该 key 不存在将创建一个key 并赋值该 number,如果 key 存在,但 value 不是长整型 ,将报错

  public Long increment(String key, long number) 
        return redisTemplate.opsForValue().increment(key, number);

对一个 key-value 的值进行加减操作,如果该 key 不存在将创建一个key 并赋值该 number,如果 key 存在,但 value 不是纯数字 ,将报错

  public Double increment(String key, double number) 
        return redisTemplate.opsForValue().increment(key, number);

将数据放入set缓存

   public void sSet(String key, String value) 
        redisTemplate.opsForSet().add(key, value);

获取变量中的值

 public Set<Object> members(String key) 
        return redisTemplate.opsForSet().members(key);

随机获取变量中指定个数的元素

 public void randomMembers(String key, long count) 
        redisTemplate.opsForSet().randomMembers(key, count);

随机获取变量中的元素

  public Object randomMember(String key) 
        return redisTemplate.opsForSet().randomMember(key);

弹出变量中的元素

 public Object pop(String key) 
        return redisTemplate.opsForSet().pop("setValue");

移除指定key 的过期时间

  public boolean persist(String key) 
        return redisTemplate.boundValueOps(key).persist();

获取变量中值的长度

  public long size(String key) 
        return redisTemplate.opsForSet().size(key);

根据value从一个set中查询,是否存在

 public boolean sHasKey(String key, Object value) 
        return redisTemplate.opsForSet().isMember(key, value);

完整的工具类RedisUtil：

package com.hookapi.common;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @author: muxiongxiong
 * @date: 2023年02月22日 下午 5:48
 * 公众号：雄雄的小课堂
 * 博客：https://blog.csdn.net/qq_34137397
 * 个人站：http://www.穆雄雄.com
 * 个人站：http://www.muxiongxiong.cn
 * @Description: 类的描述
 */
@Component
public class RedisUtil 

    @Autowired
    private RedisTemplate redisTemplate;
    /**
     * 给一个指定的 key 值附加过期时间
     *
     * @param key
     * @param time
     * @return
     */
    public boolean expire(String key, long time) 
        return redisTemplate.expire(key, time, TimeUnit.SECONDS);
    
    /**
     * 根据key 获取过期时间
     *
     * @param key
     * @return
     */
    public long getTime(String key) 
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    
    /**
     * 根据key 获取过期时间
     *
     * @param key
     * @return
     */
    public boolean hasKey(String key) 
        return redisTemplate.hasKey(key);
    
    /**
     * 移除指定key 的过期时间
     *
     * @param key
     * @return
     */
    public boolean persist(String key) 
        return redisTemplate.boundValueOps(key).persist();
    

    //- - - - - - - - - - - - - - - - - - - - -  String类型 - - - - - - - - - - - - - - - - - - - -

    /**
     * 根据key获取值
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) 
        return key == null ? null : redisTemplate.opsForValue().get(key);
    

    /**
     * 将值放入缓存
     *
     * @param key   键
     * @param value 值
     * @return true成功 false 失败
     */
    public void set(String key, String value) 
        redisTemplate.opsForValue().set(key, value);
    

    /**
     * 将值放入缓存并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) -1为无期限
     * @return true成功 false 失败
     */
    public void set(String key, String value, long time) 
        if (time > 0) 
            redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
         else 
            redisTemplate.opsForValue().set(key, value);
        
    

    /**
     * 批量添加 key (重复的键会覆盖)
     *
     * @param keyAndValue
     */
    public void batchSet(Map<String, String> keyAndValue) 
        redisTemplate.opsForValue().multiSet(keyAndValue);
    

    /**
     * 批量添加 key-value 只有在键不存在时,才添加
     * map 中只要有一个key存在,则全部不添加
     *
     * @param keyAndValue
     */
    public void batchSetIfAbsent(Map<String, String> keyAndValue) 
        redisTemplate.opsForValue().multiSetIfAbsent(keyAndValue);
    

    /**
     * 对一个 key-value 的值进行加减操作,
     * 如果该 key 不存在 将创建一个key 并赋值该 number
     * 如果 key 存在,但 value 不是长整型 ,将报错
     *
     * @param key
     * @param number
     */
    public Long increment(String key, long number) 
        return redisTemplate.opsForValue().increment(key, number);
    

    /**
     * 对一个 key-value 的值进行加减操作,
     * 如果该 key 不存在 将创建一个key 并赋值该 number
     * 如果 key 存在,但 value 不是 纯数字 ,将报错
     *
     * @param key
     * @param number
     */
    public Double increment(String key, double number) 
        return redisTemplate.opsForValue().increment(key, number);
    

    //- - - - - - - - - - - - - - - - - - - - -  set类型 - - - - - - - - - - - - - - - - - - - -

    /**
     * 将数据放入set缓存
     *
     * @param key 键
     * @return
     */
    public void sSet(String key, String value) 
        redisTemplate.opsForSet().add(key, value);
    

    /**
     * 获取变量中的值
     *
     * @param key 键
     * @return
     */
    public Set<Object> members(String key) 
        return redisTemplate.opsForSet().members(key);
    

    /**
     * 随机获取变量中指定个数的元素
     *
     * @param key   键
     * @param count 值
     * @return
     */
    public void randomMembers(String key, long count) 
        redisTemplate.opsForSet().randomMembers(key, count);
    

    /**
     * 随机获取变量中的元素
     *
     * @param key 键
     * @return
     */
    public Object randomMember(String key) 
        return redisTemplate.opsForSet().randomMember(key);
    

    /**
     * 弹出变量中的元素
     *
     * @param key 键
     * @return
     */
    public Object pop(String key) 
        return redisTemplate.opsForSet().pop("setValue");
    

    /**
     * 获取变量中值的长度
     *
     * @param key 键
     * @return
     */
    public long size(String key) 
        return redisTemplate.opsForSet().size(key);
    

    /**
     * 根据value从一个set中查询,是否存在
     *
     * @param key   键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key, Object value) 
        return redisTemplate.opsForSet().isMember(key, value);
    

    /**
     * 检查给定的元素是否在变量中。
     *
     * @param key 键
     * @param obj 元素对象
     * @return
     */
    public boolean isMember(String key, Object obj) 
        return redisTemplate.opsForSet().isMember(key, obj);
    

    /**
     * 转移变量的元素值到目的变量。
     *
     * @param key     键
     * @param value   元素对象
     * @param destKey 元素对象
     * @return
     */
    public boolean move(String key, String value, String destKey) 
        return redisTemplate.opsForSet().move(key, value, destKey);
    

    /**
     * 批量移除set缓存中元素
     *
     * @param key    键
     * @param values 值
     * @return
     */
    public void remove(String key, Object... values) 
        redisTemplate.opsForSet().remove(key, values);
    

    /**
     * 通过给定的key求2个set变量的差值
     *
     * @param key     键
     * @param destKey 键
     * @return
     */
    public Set<Set> difference(String key, String destKey) 
        return redisTemplate.opsForSet().difference(key, destKey);
    


    //- - - - - - - - - - - - - - - - - - - - -  hash类型 - - - - - - - - - - - - - - - - - - - -

    /**
     * 加入缓存
     *
     * @param key 键
     * @param map 键
     * @return
     */
    public void add(String key, Map<String, String> map) 
        redisTemplate.opsForHash().putAll(key, map);
    

    /**
     * 获取 key 下的 所有  hashkey 和 value
     *
     * @param key 键
     * @return
     */
    public Map<Object, Object> getHashEntries(String key) 
        return redisTemplate.opsForHash().entries(key);
    

    /**
     * 验证指定 key 下 有没有指定的 hashkey
     *
     * @param key
     * @param hashKey
     * @return
     */
    public boolean hashKey(String key, String hashKey) 
        return redisTemplate.opsForHash().hasKey(key, hashKey);
    

    /**
     * 获取指定key的值string
     *
     * @param key  键
     * @param key2 键
     * @return
     */
    public String getMapString(String key, String key2) 
        return redisTemplate.opsForHash().get("map1", "key1").toString();
    

    /**
     * 获取指定的值Int
     *
     * @param key  键
     * @param key2 键
     * @return
     */
    public Integer getMapInt(String key, String key2) 
        return (Integer) redisTemplate.opsForHash().get("map1", "key1");
    

    /**
     * 弹出元素并删除
     *
     * @param key 键
     * @return
     */
    public String popValue(String key) 
        return redisTemplate.opsForSet().pop(key).toString();
    

    /**
     * 删除指定 hash 的 HashKey
     *
     * @param key
     * @param hashKeys
     * @return 删除成功的 数量
     */
    public Long delete(String key, String... hashKeys) 
        return redisTemplate.opsForHash().delete(key, hashKeys);
    

    /**
     * 给指定 hash 的 hashkey 做增减操作
     *
     * @param key
     * @param hashKey
     * @param number
     * @return
     */
    public Long increment(String key, String hashKey, long number以上是关于springboot中集成redis，二次封装成工具类的主要内容，如果未能解决你的问题，请参考以下文章 
 Redis - Springboot中集成多个Redis客户端统一管理
 springboot中集成memcached
 在spring中集成EventBus
 对RedisTemplate接口二次封装成自定义工具接口
 Springboot中集成swagger
 在SpringBoot中集成单元测试