Redis 工具类

pom 文件中添加依赖

        <!-- Redis -->
        <!-- 引入 redis 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>2.6.3</version>
        </dependency>


        <!-- JSON -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.79</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.13.2.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.13.1</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-annotations -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.13.2</version>
        </dependency>

RedisUtil 类

package com.zcq.util;

import com.alibaba.fastjson.JSON;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.MapperFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.core.JsonProcessingException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

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


/**
 * Redis 工具类
 *
 * @author z
 * @link redis https://blog.csdn.net/qq_42907552/article/details/112131000
 */
@Service
public class RedisUtil {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Autowired
    private ObjectMapper objectMapper;

    /**
     * 是否包含Key
     */
    public boolean hasKey(String key) {
        // 这里有可能有空值警告，所以要 Boolean.TRUE 判断准确性
        // https://blog.csdn.net/qq_40822742/article/details/112291105
        return Boolean.TRUE.equals(stringRedisTemplate.hasKey(key));
    }

    /**
     * 存入redis time默认单位是小时，使用时请自行计算
     */
    public void set(String key, Object o, long time) {
        this.deleteKey(key);
        if (StringUtils.isEmpty(o)) {
            return;
        }
        stringRedisTemplate.opsForValue().set(key, JSON.toJSONString(o), time, TimeUnit.HOURS);
    }

    /**
     * value+=1
     */
    public Long increment(String key) {
        return stringRedisTemplate.opsForValue().increment(key);
    }

    /**
     * 获取缓存数据 统一返回String类型，使用时请自行转换
     */
    public String get(String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }

    /**
     * redis删除单个key
     */
    public boolean deleteKey(String key) {
        return Boolean.TRUE.equals(stringRedisTemplate.delete(key));
    }


    /**
     * 删除多个 key
     */
    public Long deleteKeys(String keys) {
        Set key = stringRedisTemplate.keys(keys + "");
        return stringRedisTemplate.delete(key);
    }

    public Long deleteKeys(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                stringRedisTemplate.delete(key[0]);
                return 1L;
            } else {
                return stringRedisTemplate.delete(Arrays.asList(key));
            }
        }
        return 0L;
    }

    /**
     * 此处要注意rightPushAll的坑，下一篇会详细介绍向右添加
     */
    public void rightPushAll(String key, List list) throws JsonProcessingException {
        // 先删除再添加
        this.deleteKey(key);
        String[] objArr = new String[list.size()];
        for (int i = 0; i < list.size(); i++) {
            objArr[i] = this.beanToString(list.get(i));
        }
        stringRedisTemplate.opsForList().rightPushAll(key, objArr);
    }

    /**
     * redis分布式锁 时间单位是分钟，请自行计算
     */
    public boolean setIfAbsent(String key, String value, long time) {
        return Boolean.TRUE.equals(
                stringRedisTemplate
                        .opsForValue()
                        .setIfAbsent(key, value, time, TimeUnit.MINUTES)
        );
    }

    /**
     * 通过索引获取redis里面的数据
     */
    public List rang(String key, long start, long end) {
        return stringRedisTemplate.opsForList().range(key, start, end);
    }

    /**
     * String 转换成 javaBean 使用完 get 返回 String 可使用此方法转换 javaBean
     */
    public Object stringToBean(String str, Class<?> t) throws JsonProcessingException {
        if (StringUtils.isEmpty(str)) {
            return null;
        }
        //忽略大小写
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        objectMapper.configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES, true);
        return objectMapper.readValue(JSON.parse(str).toString(), t);
    }


    /**
     * javaBean转String
     */
    public String beanToString(Object obj) throws JsonProcessingException {
        return objectMapper.writeValueAsString(obj);
    }
}