Spring Boot 访问Redis | 老蒋的知识库

Spring Boot 访问Redis

发表于 2025-03-05 | 分类于 Java | 0 | 阅读次数 28

Docker部署Redis
Mvn配置
Redis配置文件
代码

Docker部署Redis

# docker部署redis，密码 12345678
docker run -d --name redis --network ai_network -p 6379:6379 redis:7.4.2 --requirepass "12345678"

Mvn配置

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

Redis配置文件

最新Spring Boot多了个Data字段，如果配置不生效检查下版本

spring:
  data: # 多出来的字段
    redis:
      host: localhost
      port: 6379
      password: 12345678
      database: 0

代码

自定义`customRedisTemplate`序列化方法

这样通过工具访问redis查看的时候就不是乱码的了。

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
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
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> customRedisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);

        // 使用 StringRedisSerializer 序列化键（Key）
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());

        ObjectMapper objectMapper = new ObjectMapper();
        //序列化包括类型描述 否则反向序列化实体会报错，一律都为JsonObject
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.activateDefaultTyping(objectMapper.getPolymorphicTypeValidator(), ObjectMapper.DefaultTyping.NON_FINAL);

        // 使用 Jackson2JsonRedisSerializer 序列化值（Value）
        Jackson2JsonRedisSerializer<Object> valueSerializer = new Jackson2JsonRedisSerializer<>(objectMapper, Object.class);

        template.setValueSerializer(valueSerializer);
        template.setHashValueSerializer(valueSerializer);

        template.afterPropertiesSet();
        return template;
    }
}

`RedisService`代理服务类，封装一层Redis操作方法


import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * spring redis 工具类
 **/
@SuppressWarnings(value = {"unchecked", "rawtypes"}) // 无视泛型的Idea代码警告
@Component
public class RedisService {

    private final RedisTemplate redisTemplate;

    public RedisService(@Qualifier("customRedisTemplate") RedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }


    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key   缓存的键值
     * @param value 缓存的值
     */
    public <T> void setCacheObject(final String key, final T value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key      缓存的键值
     * @param value    缓存的值
     * @param timeout  时间
     * @param timeUnit 时间颗粒度
     */
    public <T> void setCacheObject(final String key, final T value, final Long timeout, final TimeUnit timeUnit) {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }

    /**
     * 设置有效时间
     *
     * @param key     Redis键
     * @param timeout 超时时间
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout) {
        return expire(key, timeout, TimeUnit.SECONDS);
    }

    /**
     * 设置有效时间
     *
     * @param key     Redis键
     * @param timeout 超时时间
     * @param unit    时间单位
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout, final TimeUnit unit) {
        return redisTemplate.expire(key, timeout, unit);
    }

    /**
     * 获取有效时间
     *
     * @param key Redis键
     * @return 有效时间
     */
    public long getExpire(final String key) {
        return redisTemplate.getExpire(key);
    }

    /**
     * 判断 key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public Boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 获得缓存的基本对象。
     *
     * @param key 缓存键值
     * @return 缓存键值对应的数据
     */
    public <T> T getCacheObject(final String key) {
        ValueOperations<String, T> operation = redisTemplate.opsForValue();
        return operation.get(key);
    }

    /**
     * 删除单个对象
     *
     * @param key
     */
    public boolean deleteObject(final String key) {
        return redisTemplate.delete(key);
    }

    /**
     * 删除集合对象
     *
     * @param collection 多个对象
     * @return
     */
    public boolean deleteObject(final Collection collection) {
        return redisTemplate.delete(collection) > 0;
    }

    /**
     * 缓存List数据
     *
     * @param key      缓存的键值
     * @param dataList 待缓存的List数据
     * @return 缓存的对象
     */
    public <T> long setCacheList(final String key, final List<T> dataList) {
        Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
        return count == null ? 0 : count;
    }

    /**
     * 缓存List数据，单个增加
     *
     * @param key  缓存的键值
     * @param data 待缓存的List数据
     * @return 缓存的对象
     */
    public <T> long setCacheList(final String key, final T data) {
        Long count = redisTemplate.opsForList().rightPush(key, data);
        return count == null ? 0 : count;
    }


    /**
     * 获得缓存的list对象：指定范围
     * 下标数值如果为负数则表示倒数，如需提取倒数2位：start = -2、 end = -1
     *
     * @param key   缓存的键值
     * @param start 开始下标
     * @param end   结束下标
     * @return 缓存键值对应的数据
     */
    public <T> List<T> getCacheList(final String key, final long start, final long end) {
        return redisTemplate.opsForList().range(key, start, end);
    }


    /**
     * 获得缓存的list对象：根据参数 num 的值，获取特定数量的值
     *
     * @param key 缓存的键值
     * @param num 获取的数量
     *            num > 0，表示获取前几位
     *            num < 0，表示获取到倒数第几位
     *            num == 0，表示获取全部
     * @return 缓存键值对应的数据
     */
    public <T> List<T> getCacheList(final String key, final long num) {
        return this.getCacheList(key, 0, num < 1 ? num : num - 1);
    }


    /**
     * 获得缓存的list对象：所有对象
     *
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public <T> List<T> getCacheList(final String key) {
        return this.getCacheList(key, 0, -1);
    }


    /**
     * 获得缓存的list对象：获取并移除指定范围内的数据。
     *
     * @param key   缓存的键值
     * @param start 开始下标
     * @param end   结束下标
     * @return 缓存键值对应的数据
     */
    public <T> List<T> removeGetCacheList(final String key, final long start, final long end) {
        List<T> l = (List<T>) redisTemplate.execute(new SessionCallback<List<Object>>() {
            public List<T> execute(RedisOperations operations) throws DataAccessException {
                /*
                  通过事务保证redis原子性操作
                  1. 提取指定范围内数据
                  2. 剪切保留 end 到 最后一位数据（注：此时会少移除左侧一条数据，不一步到位原因：移除数据时`trim([超过list最大值], -1)`会保留一条数据）
                  3. 再从左移除一条多余数据
                 */
                operations.multi();
                operations.opsForList().range(key, start, end);
                operations.opsForList().trim(key, end, -1);
                operations.opsForList().rightPop(key);
                return operations.exec();
            }
        });

        return (List<T>) l.get(0);
    }


    /**
     * 获得缓存的list对象：根据参数 num 的值，移除并获取list特定数量的数据。
     *
     * @param key 缓存的键值
     * @param num 获取的数量
     *            num > 0，表示获取前几位
     *            num < 0，表示获取到倒数第几位
     *            num == 0，表示获取全部
     * @return 缓存键值对应的数据
     */
    public <T> List<T> removeGetCacheList(final String key, final long num) {
        return this.removeGetCacheList(key, 0, num < 1 ? num : num - 1);
    }

    /**
     * 获得缓存的list对象：移除并获取list所有的数据
     *
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public <T> List<T> removeGetCacheList(final String key) {
        return this.removeGetCacheList(key, 0, -1);
    }

    /**
     * 移除缓存的list对象
     *
     * @param key   缓存的键值
     * @param count 开始下标
     *              count > 0 : 从表头开始向表尾搜索，移除与 VALUE 相等的元素，数量为 COUNT 。
     *              count < 0 : 从表尾开始向表头搜索，移除与 VALUE 相等的元素，数量为 COUNT 的绝对值。
     *              count = 0 : 移除表中所有与 VALUE 相等的值。
     * @param value 匹配的值
     * @return 缓存键值对应的数据
     */
    public Long removeCacheList(final String key, final long count, final Object value) {
        return redisTemplate.opsForList().remove(key, count, value);
    }

    /**
     * 移除缓存的list对象: 移除表中所有与 VALUE 相等的值。
     *
     * @param key   缓存的键值
     * @param value 匹配的值
     * @return 缓存键值对应的数据
     */
    public Long removeCacheList(final String key, final Object value) {
        return removeCacheList(key, 0, value);
    }


    /**
     * 缓存Set
     *
     * @param key     缓存键值
     * @param dataSet 缓存的数据
     * @return 缓存数据的对象
     */
    public <T> BoundSetOperations<String, T> setCacheSet(final String key, final 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(final String key) {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 缓存Map
     *
     * @param key
     * @param dataMap
     */
    public <T> void setCacheMap(final String key, final Map<String, T> dataMap) {
        if (dataMap != null) {
            redisTemplate.opsForHash().putAll(key, dataMap);
        }
    }

    /**
     * 获得缓存的Map
     *
     * @param key
     * @return
     */
    public <T> Map<String, T> getCacheMap(final String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 往Hash中存入数据
     *
     * @param key   Redis键
     * @param hKey  Hash键
     * @param value 值
     */
    public <T> void setCacheMapValue(final String key, final String hKey, final T value) {
        redisTemplate.opsForHash().put(key, hKey, value);
    }

    /**
     * 获取Hash中的数据
     *
     * @param key  Redis键
     * @param hKey Hash键
     * @return Hash中的对象
     */
    public <T> T getCacheMapValue(final String key, final String hKey) {
        HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
        return opsForHash.get(key, hKey);
    }

    /**
     * 获取多个Hash中的数据
     *
     * @param key   Redis键
     * @param hKeys Hash键集合
     * @return Hash对象集合
     */
    public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys) {
        return redisTemplate.opsForHash().multiGet(key, hKeys);
    }

    /**
     * 删除Hash中的某条数据
     *
     * @param key  Redis键
     * @param hKey Hash键
     * @return 是否成功
     */
    public boolean deleteCacheMapValue(final String key, final String hKey) {
        return redisTemplate.opsForHash().delete(key, hKey) > 0;
    }

    /**
     * 获得缓存的基本对象列表
     *
     * @param pattern 字符串前缀
     * @return 对象列表
     */
    public Collection<String> keys(final String pattern) {
        return redisTemplate.keys(pattern);
    }
}

本文作者： jagger
本文链接： /archives/springboot-fang-wen-redis
版权声明： 本博客所有文章除特别声明外，均采用CC BY-NC-SA 3.0 许可协议。转载请注明出处！