AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

总结下项目中使用的RedisTemplate

2023-01-08 257
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
Redis 开源版，标准版 2GB
推荐场景：
搭建游戏排行榜
云数据库 Tair（兼容Redis），内存型 2GB
推荐场景：
通过缓存加速数据库访问
简介： redis作为当下最流行的缓存解决方案，这篇文章便是总结redis在实际开发中与SpringBoot的整合。

前言：

redis作为当下最流行的缓存解决方案，这篇文章便是总结redis在实际开发中与SpringBoot的整合。


一.还原设计过程


这部分总结RedisTemplate从定义到使用的过程，并还原这个设计过程。


1.引入依赖，修改配置文件


依赖如下：

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


提供redis的配置，如下：

spring.redis.port=6379
spring.redis.host=192.168.150.101
spring.redis.database=0


2.注入自定义的RedisTemplate


我们知道，自己定义RedisTemplate并注入Spring容器中，会覆盖掉默认的RedisTemplate。

@Configuration
public class RedisConfig {
    //重新注入RedisTemplate，重新注入会覆盖掉Spring默认提供的
    @Bean
    public RedisTemplate<String,Object> getRedisTemplate(RedisConnectionFactory factoryBean){
        System.out.println("自定义的RedisTemplate被初始化了");
        RedisTemplate redisTemplate = new RedisTemplate();
        System.out.println("真正使用的factoryBean:"+factoryBean.toString());
        redisTemplate.setConnectionFactory(factoryBean);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
//        redisTemplate.setHashValueSerializer(n);
        //自定义redisTemplate必须执行该方法
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}


启动项目查看，自定义的RedisTemplate有没有初始化，并且查看默认使用的连接工厂是谁。

20210331192252889.gif


从图中可以看出控制台输出了两行

自定义的RedisTemplate被初始化了
真正使用的factoryBean:org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory@6136998b


可以看出自定义的RedisTemplate被初始化了，且使用的是LettuceConnectionFactory连接工厂，这里我们使用的是默认的工厂里的参数，然后我们去使用下自己注入的RedisTemplate，实现个接口如下：

@Controller
public class TestRedisController {
    @Autowired
    RedisTemplate redisTemplate;
    @RequestMapping("/test")
    public void test2(){
        //设置序列化策略
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        //获取值，这个过程自动反序列化
        redisTemplate.opsForValue().set("key","value");
        redisTemplate.opsForHash().put("外键","内键","值");
        System.out.println(redisTemplate.opsForValue().get("key"));
        System.out.println(redisTemplate.opsForHash().get("外键","内键"));
    }
}


然后调用该接口，查看结果：


2021033119284390.gif


请忽略报错，通过控制台可以看到数据正常存取了，没啥问题，我们测试的类型还是比较简单，来自定义一个类型看看是否可以正常获取到，自定义类型如下：

@Data
public class Human implements Serializable {
    private String name;
    private Integer old;
    private Double height;
    private String like;
    private Boolean sex;
    private List<String> list;
}


然后改写控制器，如下：

@Controller
public class TestRedisController {
    @Autowired
    RedisTemplate redisTemplate;
    @RequestMapping("/test")
    public void test2(){
        Human human = new Human();
        human.setHeight(50d);
        human.setLike("吃");
        human.setList(Arrays.asList("父亲","母亲","妻子"));
        human.setName("秦始皇");
        human.setSex(true);
        human.setOld(20);
        //设置序列化策略
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        //获取值，这个过程自动反序列化
        redisTemplate.opsForValue().set("key","value");
        redisTemplate.opsForHash().put("外键","内键",human);
        System.out.println(redisTemplate.opsForValue().get("key"));
        System.out.println(redisTemplate.opsForHash().get("外键","内键"));
    }
}


然后我们重启看下是否正确获取了：


20210331195824700.gif


我们可以看到正常获取了，使用没有问题。


3.为hashvalue设置序列化策略


经笔者反复测试，并没有发现这块不设置对hashvalue值的获取有什么影响，既然加上和不加上效果一样，那么选择加上。首先我们需要提供一个序列化对象的类RedisObjectSerializer


public class RedisObjectSerializer implements RedisSerializer<Object> {
    // 做一个空数组，不是null
    private static final byte[] EMPTY_BYTE_ARRAY = new byte[0];
    // 为了方便进行对象与字节数组的转换，所以应该首先准备出两个转换器
    private final Converter<Object, byte[]> serializingConverter = new SerializingConverter();
    private final Converter<byte[], Object> deserializingConverter = new DeserializingConverter();
    @Override
    public byte[] serialize(Object obj) {
        // 这个时候没有要序列化的对象出现，所以返回的字节数组应该就是一个空数组
        if (obj == null) {
            return EMPTY_BYTE_ARRAY;
        }
        // 将对象变为字节数组
        return this.serializingConverter.convert(obj);
    }
    @Override
    public Object deserialize(byte[] data) {
        // 此时没有对象的内容信息
        if (data == null || data.length == 0) {
            return null;
        }
        return this.deserializingConverter.convert(data);
    }
}

然后修改，调用的部分如下：


20210331200308441.png


然后测试，反复结果都是一样，并没有任何区别，这里记录下，希望知道区别的小伙伴不吝赐教。


4.自定义redis工具类


使用redisTemplate，去写代码会有很多重复部分，所以项目里并不会去直接使用redisTemplate，而是通过封装一个工具类，我们每次去调用这个工具类。工具类代码如下：

public class RedisRepository {
    /**
     * 默认编码
     */
    private static final Charset DEFAULT_CHARSET = StandardCharsets.UTF_8;
    /**
     * key序列化
     */
    private static final RedisSerializer STRING_SERIALIZER = new StringRedisSerializer();
    /**
     * value 序列化
     */
    private static final RedisSerializer OBJECT_SERIALIZER = new RedisObjectSerializer();
    /**
     * Spring Redis Template
     */
    private RedisTemplate<String, Object> redisTemplate;
    public RedisRepository(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
        this.redisTemplate.setKeySerializer(STRING_SERIALIZER);
        this.redisTemplate.setHashKeySerializer(STRING_SERIALIZER);
        this.redisTemplate.setValueSerializer(OBJECT_SERIALIZER);
        this.redisTemplate.setHashValueSerializer(OBJECT_SERIALIZER);
    }
    /**
    * 存储hash对象
     */
    public void set(String keyS,String keyIn,Object value){
        redisTemplate.opsForHash().put(keyS,keyIn,value);
    }
    /**
     * 获取hash对象
     */
    public Object get(String keyS,String keyIn){
       return redisTemplate.opsForHash().get(keyS,keyIn);
    }
    /**
     * 获取链接工厂
     */
    public RedisConnectionFactory getConnectionFactory() {
        return this.redisTemplate.getConnectionFactory();
    }
    /**
     * 获取 RedisTemplate对象
     */
    public RedisTemplate<String, Object> getRedisTemplate() {
        return redisTemplate;
    }
    /**
     * 清空DB
     *
     * @param node redis 节点
     */
    public void flushDB(RedisClusterNode node) {
        this.redisTemplate.opsForCluster().flushDb(node);
    }
    /**
     * 添加到带有 过期时间的  缓存
     *
     * @param key   redis主键
     * @param value 值
     * @param time  过期时间(单位秒)
     */
    public void setExpire(final byte[] key, final byte[] value, final long time) {
        redisTemplate.execute((RedisCallback<Long>) connection -> {
            connection.setEx(key, time, value);
//            log.debug("[redisTemplate redis]放入 缓存  url:{} ========缓存时间为{}秒", key, time);
            return 1L;
        });
    }
    /**
     * 添加到带有 过期时间的  缓存
     *
     * @param key   redis主键
     * @param value 值
     * @param time  过期时间(单位秒)
     */
    public void setExpire(final String key, final Object value, final long time) {
        redisTemplate.execute((RedisCallback<Long>) connection -> {
            RedisSerializer<String> serializer = getRedisSerializer();
            byte[] keys = serializer.serialize(key);
            byte[] values = OBJECT_SERIALIZER.serialize(value);
            connection.setEx(keys, time, values);
            return 1L;
        });
    }
    /**
     * 添加到带有 过期时间的  缓存
     *
     * @param key  redis主键
     * @param time 过期时间(单位秒)
     */
    public void setExpire(final String key, final long time) {
        redisTemplate.expire(key, time, TimeUnit.SECONDS);
    }
    /**
     * 一次性添加数组到   过期时间的  缓存，不用多次连接，节省开销
     *
     * @param keys   redis主键数组
     * @param values 值数组
     * @param time   过期时间(单位秒)
     */
    public void setExpire(final String[] keys, final Object[] values, final long time) {
        redisTemplate.execute((RedisCallback<Long>) connection -> {
            RedisSerializer<String> serializer = getRedisSerializer();
            for (int i = 0; i < keys.length; i++) {
                byte[] bKeys = serializer.serialize(keys[i]);
                byte[] bValues = OBJECT_SERIALIZER.serialize(values[i]);
                connection.setEx(bKeys, time, bValues);
            }
            return 1L;
        });
    }
    /**
     * 一次性添加数组到   过期时间的  缓存，不用多次连接，节省开销
     *
     * @param keys   the keys
     * @param values the values
     */
    public void set(final String[] keys, final Object[] values) {
        redisTemplate.execute((RedisCallback<Long>) connection -> {
            RedisSerializer<String> serializer = getRedisSerializer();
            for (int i = 0; i < keys.length; i++) {
                byte[] bKeys = serializer.serialize(keys[i]);
                byte[] bValues = OBJECT_SERIALIZER.serialize(values[i]);
                connection.set(bKeys, bValues);
            }
            return 1L;
        });
    }
    /**
     * 添加到缓存
     *
     * @param key   the key
     * @param value the value
     */
    public void set(final String key, final Object value) {
        redisTemplate.execute((RedisCallback<Long>) connection -> {
            RedisSerializer<String> serializer = getRedisSerializer();
            byte[] keys = serializer.serialize(key);
            byte[] values = OBJECT_SERIALIZER.serialize(value);
            connection.set(keys, values);
//            log.debug("[redisTemplate redis]放入 缓存  url:{}", key);
            return 1L;
        });
    }
    /**
     * 查询在这个时间段内即将过期的key
     *
     * @param key  the key
     * @param time the time
     * @return the list
     */
    public List<String> willExpire(final String key, final long time) {
        final List<String> keysList = new ArrayList<>();
        redisTemplate.execute((RedisCallback<List<String>>) connection -> {
            Set<String> keys = redisTemplate.keys(key + "*");
            for (String key1 : keys) {
                Long ttl = connection.ttl(key1.getBytes(DEFAULT_CHARSET));
                if (0 <= ttl && ttl <= 2 * time) {
                    keysList.add(key1);
                }
            }
            return keysList;
        });
        return keysList;
    }
    /**
     * 查询在以keyPatten的所有  key
     *
     * @param keyPatten the key patten
     * @return the set
     */
    public Set<String> keys(final String keyPatten) {
        return redisTemplate.execute((RedisCallback<Set<String>>) connection -> redisTemplate.keys("*" + keyPatten + "*"));
    }
    /**
     * 根据key获取对象
     *
     * @param key the key
     * @return the byte [ ]
     */
    public byte[] get(final byte[] key) {
        byte[] result = redisTemplate.execute((RedisCallback<byte[]>) connection -> connection.get(key));
//        log.debug("[redisTemplate redis]取出 缓存  url:{} ", key);
        return result;
    }
    /**
     * 根据key获取对象
     *
     * @param key the key
     * @return the string
     */
    public Object get(final String key) {
        Object resultStr = redisTemplate.execute((RedisCallback<Object>) connection -> {
            RedisSerializer<String> serializer = getRedisSerializer();
            byte[] keys = serializer.serialize(key);
            byte[] values = connection.get(keys);
            return OBJECT_SERIALIZER.deserialize(values);
        });
//        log.debug("[redisTemplate redis]取出 缓存  url:{} ", key);
        return resultStr;
    }
    /**
     * 根据key获取对象
     *
     * @param keyPatten the key patten
     * @return the keys values
     */
    public Map<String, Object> getKeysValues(final String keyPatten) {
//        log.debug("[redisTemplate redis]  getValues()  patten={} ", keyPatten);
        return redisTemplate.execute((RedisCallback<Map<String, Object>>) connection -> {
            RedisSerializer<String> serializer = getRedisSerializer();
            Map<String, Object> maps = new HashMap<>(16);
            Set<String> keys = redisTemplate.keys(keyPatten + "*");
            if (!CollectionUtils.isEmpty(keys)) {
                for (String key : keys) {
                    byte[] bKeys = serializer.serialize(key);
                    byte[] bValues = connection.get(bKeys);
                    Object value = OBJECT_SERIALIZER.deserialize(bValues);
                    maps.put(key, value);
                }
            }
            return maps;
        });
    }
    /**
     * Ops for hash hash operations.
     *
     * @return the hash operations
     */
    public HashOperations<String, String, Object> opsForHash() {
        return redisTemplate.opsForHash();
    }
    /**
     * 对HashMap操作
     *
     * @param key       the key
     * @param hashKey   the hash key
     * @param hashValue the hash value
     */
    public void putHashValue(String key, String hashKey, Object hashValue) {
//        log.debug("[redisTemplate redis]  putHashValue()  key={},hashKey={},hashValue={} ", key, hashKey, hashValue);
        opsForHash().put(key, hashKey, hashValue);
    }
    /**
     * 获取单个field对应的值
     *
     * @param key     the key
     * @param hashKey the hash key
     * @return the hash values
     */
    public Object getHashValues(String key, String hashKey) {
//        log.debug("[redisTemplate redis]  getHashValues()  key={},hashKey={}", key, hashKey);
        return opsForHash().get(key, hashKey);
    }
    /**
     * 根据key值删除
     *
     * @param key      the key
     * @param hashKeys the hash keys
     */
    public void delHashValues(String key, Object... hashKeys) {
//        log.debug("[redisTemplate redis]  delHashValues()  key={}", key);
        opsForHash().delete(key, hashKeys);
    }
    /**
     * key只匹配map
     *
     * @param key the key
     * @return the hash value
     */
    public Map<String, Object> getHashValue(String key) {
//        log.debug("[redisTemplate redis]  getHashValue()  key={}", key);
        return opsForHash().entries(key);
    }
    /**
     * 批量添加
     *
     * @param key the key
     * @param map the map
     */
    public void putHashValues(String key, Map<String, Object> map) {
        opsForHash().putAll(key, map);
    }
    /**
     * 集合数量
     *
     * @return the long
     */
    public long dbSize() {
        return redisTemplate.execute(RedisServerCommands::dbSize);
    }
    /**
     * 清空redis存储的数据
     *
     * @return the string
     */
    public String flushDB() {
        return redisTemplate.execute((RedisCallback<String>) connection -> {
            connection.flushDb();
            return "ok";
        });
    }
    /**
     * 判断某个主键是否存在
     *
     * @param key the key
     * @return the boolean
     */
    public boolean exists(final String key) {
        return redisTemplate.execute((RedisCallback<Boolean>) connection -> connection.exists(key.getBytes(DEFAULT_CHARSET)));
    }
    /**
     * 删除key
     *
     * @param keys the keys
     * @return the long
     */
    public long del(final String... keys) {
        return redisTemplate.execute((RedisCallback<Long>) connection -> {
            long result = 0;
            for (String key : keys) {
                result = connection.del(key.getBytes(DEFAULT_CHARSET));
            }
            return result;
        });
    }
    public long del(byte[] key) {
        return redisTemplate.execute((RedisCallback<Long>) connection -> connection.del(key));
    }
    /**
     * 获取 RedisSerializer
     *
     * @return the redis serializer
     */
    protected RedisSerializer<String> getRedisSerializer() {
        return redisTemplate.getStringSerializer();
    }
    /**
     * 对某个主键对应的值加一,value值必须是全数字的字符串
     *
     * @param key the key
     * @return the long
     */
    public long incr(final String key) {
        return redisTemplate.execute((RedisCallback<Long>) connection -> {
            RedisSerializer<String> redisSerializer = getRedisSerializer();
            return connection.incr(redisSerializer.serialize(key));
        });
    }
    /**
     * redis List 引擎
     *
     * @return the list operations
     */
    public ListOperations<String, Object> opsForList() {
        return redisTemplate.opsForList();
    }
    /**
     * redis List数据结构 : 将一个或多个值 value 插入到列表 key 的表头
     *
     * @param key   the key
     * @param value the value
     * @return the long
     */
    public Long leftPush(String key, Object value) {
        return opsForList().leftPush(key, value);
    }
    /**
     * redis List数据结构 :移除列表key中值等于value的所有元素
     *
     * @param key   1
     * @param value 2
     * @return {@link Long}
     * @author wangchunfeng
     * @date 2020/7/28 9:57
     **/
    public Long lrem(String key, Object value) {
        return opsForList().remove(key, 0, value);
    }
    /**
     * redis List数据结构 : 移除并返回列表 key 的头元素
     *
     * @param key the key
     * @return the string
     */
    public Object leftPop(String key) {
        return opsForList().leftPop(key);
    }
    /**
     * redis List数据结构 :将一个或多个值 value 插入到列表 key 的表尾(最右边)。
     *
     * @param key   the key
     * @param value the value
     * @return the long
     */
    public Long in(String key, Object value) {
        return opsForList().rightPush(key, value);
    }
    /**
     * redis List数据结构 : 移除并返回列表 key 的末尾元素
     *
     * @param key the key
     * @return the string
     */
    public Object rightPop(String key) {
        return opsForList().rightPop(key);
    }
    /**
     * redis List数据结构 : 返回列表 key 的长度 ; 如果 key 不存在，则 key 被解释为一个空列表，返回 0 ; 如果 key 不是列表类型，返回一个错误。
     *
     * @param key the key
     * @return the long
     */
    public Long length(String key) {
        return opsForList().size(key);
    }
    /**
     * redis List数据结构 : 根据参数 i 的值，移除列表中与参数 value 相等的元素
     *
     * @param key   the key
     * @param i     the
     * @param value the value
     */
    public void remove(String key, long i, Object value) {
        opsForList().remove(key, i, value);
    }
    /**
     * redis List数据结构 : 将列表 key 下标为 index 的元素的值设置为 value
     *
     * @param key   the key
     * @param index the index
     * @param value the value
     */
    public void set(String key, long index, Object value) {
        opsForList().set(key, index, value);
    }
    /**
     * redis List数据结构 : 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 end 指定。
     *
     * @param key   the key
     * @param start the start
     * @param end   the end
     * @return the list
     */
    public List<Object> getList(String key, int start, int end) {
        return opsForList().range(key, start, end);
    }
    /**
     * redis List数据结构 : 批量存储
     *
     * @param key  the key
     * @param list the list
     * @return the long
     */
    public Long leftPushAll(String key, List<String> list) {
        return opsForList().leftPushAll(key, list);
    }
    /**
     * redis List数据结构 : 将值 value 插入到列表 key 当中，位于值 index 之前或之后,默认之后。
     *
     * @param key   the key
     * @param index the index
     * @param value the value
     */
    public void insert(String key, long index, Object value) {
        opsForList().set(key, index, value);
    }
    public Long getExpire(String key) {
        return redisTemplate.getExpire(key);
    }
    /**
     * 将key 的值设为 value ,当且仅当 key 不存在
     * 默认时间单位是秒
     *
     * @param key
     * @param value   自定义 value
     * @param seconds 自定义过期时间秒数
     * @return 设置成功返回 true 失败返回false
     */
    public boolean setNx(String key, Object value, int seconds) {
        return this.setNx(key, value, seconds, TimeUnit.SECONDS);
    }
    /**
     * 将key 的值设为 value ,当且仅当 key 不存在
     * 注：常用与分布式锁
     *
     * @param key
     * @param value
     * @param duration 时间量
     * @param timeUnit 时间单位枚举
     * @return 设置成功返回 true 失败返回false
     */
    public boolean setNx(String key, Object value, int duration, TimeUnit timeUnit) {
        if (this.exists(key)) {
            return false;
        }
        return this.exists(key) ? false : this.put(key, value, duration, timeUnit);
    }
    /**
     * 添加数据到redis
     * 自定义过期时间
     * 注：从 Redis 2.6.12 版本开始， SET 在设置操作成功完成时，返回 OK
     *
     * @param key
     * @param value
     * @param duration 时间量
     * @param timeUnit 时间单位枚举
     */
    public boolean put(final String key, final Object value, final int duration, final TimeUnit timeUnit) {
        return redisTemplate.execute((RedisCallback<Boolean>) connection -> {
            RedisSerializer<String> serializer = getRedisSerializer();
            byte[] keys = serializer.serialize(key);
            byte[] values = OBJECT_SERIALIZER.serialize(value);
            // 删除缓存数据
            connection.del(key.getBytes(DEFAULT_CHARSET));
            // 添加缓存数据
            connection.set(keys, values);
            // 设置过期时间
            long seconds = timeUnit.toSeconds(duration);
            connection.setEx(keys, seconds, values);
            return true;
        });
    }
}


注入工具类的对象到Spring容器中

  @Bean
    public RedisRepository getRedisRepository(RedisTemplate redisTemplate){
        return new RedisRepository(redisTemplate);
    }


修改测试控制器如下：

@Controller
public class TestRedisController {
    @Autowired
    RedisRepository redisRepository;
    @RequestMapping("/test")
    public void test2(){
        Human human = new Human();
        human.setHeight(50d);
        human.setLike("吃");
        human.setList(Arrays.asList("父亲","母亲","妻子"));
        human.setName("秦始皇");
        human.setSex(true);
        human.setOld(20);
        redisRepository.set("key","newvalue");
        redisRepository.set("外键","内健",human);
        System.out.println(redisRepository.get("key"));
        System.out.println(redisRepository.get("外键","内健"));
    }
}


测试结果如下：

20210331202643128.gif



可以看出值的获取与插入都是没有问题的。


二.总结


记录了一个小项目中集成redis的方案，在做的另一个大型分布式项目使用的dubbo服务提供的redis接口，看不到源码，只能通过rpc接口去调用，并看不到实现，很是遗憾，这种集成有一个很明显的缺陷就是没有自定义redis的连接池，性能其实并不高，但是作为一个小项目的使用方案，其实无伤大雅，如果后期需要提升性能。可以再实现连接池的部分。


文章标签：
云数据库 Tair（兼容 Redis）
Java
容器
应用服务中间件
NoSQL
Dubbo
Redis
Spring
缓存
相关实践学习
基于Redis实现在线游戏积分排行榜
本场景将介绍如何基于Redis数据库实现在线游戏中的游戏玩家积分排行榜功能。
云数据库 Redis 版使用教程
云数据库Redis版是兼容Redis协议标准的、提供持久化的内存数据库服务，基于高可靠双机热备架构及可无缝扩展的集群架构，满足高读写性能场景及容量需弹性变配的业务需求。 产品详情：https://www.aliyun.com/product/kvstore &nbsp; &nbsp; ------------------------------------------------------------------------- 阿里云数据库体验：数据库上云实战 开发者云会免费提供一台带自建MySQL的源数据库&nbsp;ECS 实例和一台目标数据库&nbsp;RDS实例。跟着指引，您可以一步步实现将ECS自建数据库迁移到目标数据库RDS。 点击下方链接，领取免费ECS&amp;RDS资源，30分钟完成数据库上云实战！https://developer.aliyun.com/adc/scenario/51eefbd1894e42f6bb9acacadd3f9121?spm=a2c6h.13788135.J_3257954370.9.4ba85f24utseFl
是八哥啊~
目录
相关文章
码农飞哥
|
6月前
RedisTemplate序列化的问题
RedisTemplate序列化的问题
码农飞哥
51 1
杭州小哥哥
|
8月前
|
存储 数据可视化
RedisTemplate中opsForValue()中的方法
RedisTemplate中opsForValue()中的方法
杭州小哥哥
50 0
杭州小哥哥
|
8月前
|
存储 NoSQL Redis
redisTemplate.opsForHash()
redisTemplate.opsForHash()
杭州小哥哥
91 0
赵广陆
|
缓存 Dart NoSQL
Jedis和RedisTemplate 1
Jedis和RedisTemplate
赵广陆
128 0
即兴小索奇
|
8月前
|
存储 NoSQL Java
redisTemplate.opsForValue() 懂这些就够了
redisTemplate.opsForValue() 懂这些就够了
即兴小索奇
1074 0
程序三两行
|
8月前
|
NoSQL Redis
springboot2.0整合 RedisTemplate
springboot2.0整合 RedisTemplate
程序三两行
35 0
风水道人
|
8月前
|
NoSQL Java Redis
SpringBoot中操作RedisTemplate获取redis中以某些字符串为前缀的KEY列表
SpringBoot中操作RedisTemplate获取redis中以某些字符串为前缀的KEY列表
风水道人
216 0
编程千纸鹤
|
8月前
|
存储 NoSQL Redis
RedisTemplate常用方法总结
RedisTemplate常用方法总结
编程千纸鹤
240 0
赵广陆
|
缓存 Dart Java
Jedis和RedisTemplate 2
Jedis和RedisTemplate
赵广陆
66 0
XiaoHHSuperme
|
缓存 NoSQL Java
SpringBoot自定义redisTemplate的key和value的序列化方式
SpringBoot自定义redisTemplate的key和value的序列化方式
XiaoHHSuperme
173 0