「进击Redis」二十一、RedisTemplate 可没你想的那么简单

最新推荐文章于 2024-09-02 08:18:37 发布
置顶 最新推荐文章于 2024-09-02 08:18:37 发布
阅读量996 收藏 5
点赞数 1
分类专栏： redis 学习 Java 文章标签： java redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34090008/article/details/111599680
版权
Java 同时被 3 个专栏收录
55 篇文章 1 订阅
订阅专栏
redis
34 篇文章 5 订阅
订阅专栏
学习
20 篇文章 0 订阅
订阅专栏

前言

是的，我又肝了一篇，关于RedisTemplate 。好哥哥问我为什么这么肝，我无奈的笑了说道：谁叫我氪不起（泪水又再一次打湿了我的眼睛）。好的，还有没有看过我上一篇 万字长文解析 Redis 高级客户端 Lettuce 的吗。没有看的好哥哥建议还是花个几个小时看一下（劝你善良），因为今天这篇跟前两篇都是有关系的。正如标题RedisTemplate 可没你想的那么简单，而且篇幅真的很长。
善良

概述

首先，RedisTemplate 是Spring Data Redis提供给用户的最高级的抽象客户端，用户可直接通过RedisTemplate进行多种操作，同时RedisTemplate是建立在我们上两篇讲的Jedis和Lettuce之上的。怎么理解呢？就好比我们连接Mysql数据库，我们会使用比如HiKariCP 和Druid连接池，Jedis和Lettuce的关系就跟它们两差不多。
无论像Mysql、Redis、消息中间件，我们都需要创建客户端连接、根据业务逻辑进行增删改查、关闭客户端连接等操作。Spring 中为例简化这一系列的操作，提供了模板类。举个大家很熟悉的RestTemplate类，逻辑都是一样的。
Spring 为了将数据访问中的固定和变化部分分开，将相同的数据访问流程固化到模板类中，变化的部分通过回调接口开放出来，用于具体定义数据访问和结果返回的操作，同时保证模板类是线程安全的，以便多个数据访问线程共享同一个模板实例。

使用

1 添加依赖

还是老样子，到maven中找到对应使用最多的那一个

<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
    <version>2.3.3.RELEASE</version>
</dependency>
2 添加配置

连接池这个地方有个需要注意点就是建议使用lettuce，不熟悉的可以看我上一篇万字长文解析 Redis 高级客户端 Lettuce。jedis客户端连接方式是基于tcp的阻塞式连接方式，而lettuce是基于netty的多路复用异步非阻塞的连接方案。所以这里推荐使用lettuce（悄咪咪的说一下就是我们项目中用的也是这个）。这里贴一部分主要配置，其他的就交给好哥哥们了。

spring:
  redis:
    timeout: 6000ms   # 连接超时时长（毫秒）
#    host: 127.0.0.1  #单机
#    port: 6379
    password: ''      # 密码（默认为空）
    cluster:          #集群
      nodes:
      - 127.0.0.1:6379
      - 127.0.0.1:6380
      - 127.0.0.1:6381
#   jedis:                 # jedis 连接池
    lettuce:               # lettuce 连接池
      pool:
        max-idle: 8  # 连接池中的最大空闲连接 默认8
        min-idle: 0   # 连接池中的最小空闲连接 默认0
        max-active: 8  # 连接池最大连接数 默认8 ，负数表示没有限制
        max-wait: -1ms    # 连接池最大阻塞等待时间（使用负值表示没有限制） 默认-1
3 RedisConfig 配置
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @Deacription Redis 配置类
 * @Author xjw
 **/
@Configuration
public class RedisConfig {

    /**
     * 1. Jedis、Lettuce 根据配置(二选一)
     * 2. key使用StringRedisSerializer
     * 3. value根据项目情况选择，需要以json存储，参考Lettuce配置使用Jackson2JsonRedisSerializer
     * jedis 配置方式
     */
    //@Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // 配置redisTemplate
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);
        redisTemplate.setKeySerializer(stringRedisSerializer);
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        redisTemplate.setHashValueSerializer(stringRedisSerializer);
        redisTemplate.setValueSerializer(stringRedisSerializer);
        return redisTemplate;
    }

    /**
     * Lettuce 配置方式
     *
     * @param lettuceConnectionFactory
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
        // key序列化
        RedisSerializer<?> stringSerializer = new StringRedisSerializer();
        // value序列化
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // 配置redisTemplate
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
        redisTemplate.setConnectionFactory(lettuceConnectionFactory);
        // key序列化
        redisTemplate.setKeySerializer(stringSerializer);
        // value序列化
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        // Hash key序列化
        redisTemplate.setHashKeySerializer(stringSerializer);
        // Hash value序列化
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}
4 工具类

工具类篇幅有点长，可以点负责到本地看，然后点目录跳过。

package com.xjw.config.redis;

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

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

/**
 * redis工具类
 *
 * @Author xjw
 */
@Component
public class RedisUtil {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 指定缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key 获取过期时间
     *
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key) {
        if (null == key || key.length() <= 0) {
            return -1L;
        }
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    // ============================String=============================

    /**
     * 普通缓存获取
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     *
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }

    /**
     * 普通缓存放入并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 递增
     *
     * @param key   键
     * @param delta 要增加几(大于0)
     * @return
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 递减
     *
     * @param key   键
     * @param delta 要减少几(小于0)
     * @return
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    // ================================Map=================================

    /**
     * HashGet
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return 值
     */
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 获取hashKey对应的所有键值
     *
     * @param key 键
     * @return 对应的多个键值
     */
    public Map<Object, Object> hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     *
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    public boolean hmset(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * HashSet 并设置时间
     *
     * @param key  键
     * @param map  对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public boolean hmset(String key, Map<String, Object> map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除hash表中的值
     *
     * @param key  键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }

    /**
     * 判断hash表中是否有该项的值
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     *
     * @param key  键
     * @param item 项
     * @param by   要增加几(大于0)
     * @return
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    /**
     * hash递减
     *
     * @param key  键
     * @param item 项
     * @param by   要减少记(小于0)
     * @return
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }

    // ============================set=============================

    /**
     * 根据key获取Set中的所有值
     *
     * @param key 键
     * @return
     */
    public Set<Object> sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

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

    /**
     * 将数据放入set缓存
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 将set数据放入缓存
     *
     * @param key    键
     * @param time   时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSetAndTime(String key, long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0) {
                expire(key, time);
            }
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 获取set缓存的长度
     *
     * @param key 键
     * @return
     */
    public long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 移除值为value的
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    public long setRemove(String key, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    // ===============================list=================================

    /**
     * 获取list缓存的内容
     *
     * @param key   键
     * @param start 开始
     * @param end   结束 0 到 -1代表所有值
     * @return
     */
    public List<Object> lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取list缓存的长度
     *
     * @param key 键
     * @return
     */
    public long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 通过索引 获取list中的值
     *
     * @param key   键
     * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     * @return
     */
    public Object lGetIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据索引修改list中的某条数据
     *
     * @param key   键
     * @param index 索引
     * @param value 值
     * @return
     */
    public boolean lUpdateIndex(String key, long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 移除N个值为value
     *
     * @param key   键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
    public long lRemove(String key, long count, Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
}
5 使用

这个的话就很简单了，把工具类注入，然后使用对应 API 就 OK 了。举一个小栗子把。

@Autowired
public RedisUtil redisUtil;

@GetMapping("/get")
public String get(String keyName) {
	// 设值
    redisUtil.set("hello", "world");
    // 返回String
    return String.valueOf(redisUtil.get(keyName));
}

原理

这个的主要解析get方法原理及过程，弄清楚一个基本上其他也都是差不多的，关键还是需要好哥哥们跟着代码跑一遍。

  1. 初始化
    初始化主要是要指定一个客户端，也就是类似于连接池。在这里我们配置了使用LettuceConnectionFactory，其他的话就是要配置一些像连接池的属性和序列化方式。
  2. RedisTemplate 结构解析
    RedisTemplate 作为我们使用其方法的入口类，继承了RedisAccessor实现了RedisOperations（好哥哥们可以自己看下源码）。
    • RedisAccessor类主要是对连接工厂的配置，实现了InitializingBean接口，在初始化bean时会断言是否已经配置连接工厂。另外的话主要初始化的工作在它的子类RedisTemplate中（重写了afterPropertiesSet方法）。
    • RedisOperations接口定义了RedisTemplate操作 Redis 的一些Api方法，主要提供了一些对 Redis 键，事务，运行脚本等命令的支持，不负责数据的读写。具体实现类是StringRedisTemplate、RedisTemplate 。
  3. 命令执行过程
    • 执行命令第一步需要指定需要操作对应的数据结构。比如说redisTemplate.opsForValue().get(key)，这里指定了操作基础字符串类型。opsForValue这个方法是因为RedisTemplate实现了RedisOperations。
    • 第二步针对指定的数据结构获取到对应的具体实现类。redisTemplate.opsForValue()会返回一个ValueOperations接口，它的实现类只会有一个DefaultValueOperations。当调用get方法时执行的就是DefaultValueOperations中的get方法。
    • 解析操作命令流程。DefaultValueOperations#get()方法会调用execute方法。execute方法中会执行redisTemplate.execute方法，也就是说最后执行的还是RedisTemplate中的execute方法。
    • RedisTemplate的execute方法解析。流程大概是通过配置的LettuceConnectionFactory获取一个连接（这个连接可能是新建的也可能是复用的），然后执行RedisCallback#doInRedis（实现类是ValueDeserializingRedisCallback，在调用redisTemplate.execute中通过匿名内部类的方式传入）将连接放入到回调中。
    • 解析ValueDeserializingRedisCallback类的doInRedis方法。实际上执行的是其父类AbstractOperations的doInRedis，结果这又是一个抽象方法。然后就会执行其子类的ValueDeserializingRedisCallback（就是上面说到的使用匿名内部类中的那个地方，实现了inRedis方法）。
    • 通过连接执行命令。
    • 通过配置的序列化方式执行反序列化然后返回结果。

总结

  1. 从使用上来说RedisTemplate、Jedis、Lettuce都很简单，实现上来说RedisTemplate在客户端的基础上又进行了一次封装，而且实现上还是很绕的，在理解其原理上会更加的复杂。
  2. RedisTemplate 中使用到了很多设计模式，比如说模板方法 、工厂模式 、单例模式 、动态代理 等等，源码好哥哥们还是可以去看看的。
  3. 在初始化配置的时候一定要记得配置序列化方式，不然会默认使用JdkSerializationRedisSerializer。使用这种方式的话可读性就会很差了。
  4. RedisTemplate被 Spring 高度的封装，但是在某种程度上来说有一定的局限性。比如说 RedisTemplate舍弃了客户端一些高级特性和灵活的 API

本期就到这啦，有不对的地方欢迎好哥哥们评论区留言，另外求关注、求点赞

上一篇: 万字长文解析 Redis 高级客户端 Lettuce

AnAnDawn
关注
专栏目录
记一次RedisTemplate中hash取不到数据问题的排查过程
q360501004的博客
11-14 8469
这里写自定义目录标题RedisTemplate问题描述排查过程后续研究 RedisTemplate 本人很菜，排查的这个问题比较初级。轻喷。 环境: Spring, Spring boot, RedistTemplate 问题描述 与同事商定了一个功能实现方法的时候，他那边采用离线计算，将计算结果放入Redis的Hash结构中，hash的key为用户id，value为计算的结果。我这边需要用的时候...
SpringDataRedis之RedisTemplate
m0_57509001的博客
02-10 649
RedisTemplate
WebFlux整合Redis数据放不进去也不报错
weixin_41682347的博客
01-09 638
WebFlux整合Redis数据放不进去也不报错subscribe subscribe 在set后要使用订阅subscribe才可以使提交的数据生效。 例如： reactiveRedisTemplate.opsForValue().set(HASH_NAME, product).subscribe(b -> { logger.info("success result: {}", b.toString()); }, e -> {
【主流技术】聊一聊 RedisTemplate 在 SpringBooot 里的简单应用
最新发布
weixin_43248862的博客
09-02 734
Redis 是目前互联网后端的热门中间件之一，在许多方面都有深度的应用，作为后端开发熟练掌握该技术是十分有必要的。 Redis 的五种数据类型是：1、String（字符串）；2、Hash（哈希）；3、List（列表）；4、Set（集合）；5、Sort Set （有序集合）。其余的用的比较少，本文暂不涉及。
RedisTemplate map集合使用说明-opsForHash(三)
振钧
09-02 2436
 1、put(H key, HK hashKey, HV v...
stringRedisTemplate.opsForHash().putAll时的类型转换错误java.lang.* cannot be cast to java.lang.String
Phoebe101的博客
12-25 2401
在使用BeanUtil.beanToMap将对象转换成Map时，值的类型是对象对应属性类型，而redis要求以String类型存储。使用BeanUtil.beanToMap中自带的CopyOptions方法去修改字段值的类型。
java opsForHash().put 客户端无法取值
zy_crazy_code的博客
06-26 718
redisTemplate.opsForHash().put("zhps:psss_nw:getNwOverviewData:440113","lineLenth",lineLenth); 客户端取值的时候发现是空的，用hgetall命令查看，发现Java给对象加了引号 正确取值
redisTemplate.opsForHash().putAll(Object,oMap) 方法
这介绍不了我
04-17 4923
redisTemplate.opsForHash().putAll(Object,oMap) 是 RedisTemplate 类中的一个方法，用于向 Redis 的哈希表中批量添加键值对。该方法接收两个参数：一个是哈希表的 key，另一个是一个 Map 对象，Map 对象中存储了多个键值对，其中键是哈希表中的字段名，值是字段对应的值。然后，通过 redisTemplate.opsForHash().putAll() 方法将这些键值对批量添加到了名为 "hashKey" 的哈希表中。
Redis之RedisTemplate使用（RedisTemplate工具类）
03-15
Redis之RedisTemplate使用（RedisTemplate工具类） String类型相关操作 List类型相关操作 Set类型相关操作 Map类型相关操作 ZSet类型相关操作
Redis+RedisTemplate分布式锁
01-07
Redis+RedisTemplate分布式锁
SpringBoot整合Redis(RedisTemplate )
qq_44154912的博客
03-26 1841
SpringBoot整合Redis—RedisTemplate1、创建SpringBoot工程, 添加依赖2、创建实体类3、创建控制器4、在resources包下创建配置文件application.yml5、创建启动类6、启动测试7、注意点8、五种数据类型的Java操作字符串 String列表 List集合Set有序集合Zset哈希Hash Spring Boot 整合Redis （一） spring-boot-starter-data-redis SpringBoot 使用Spring Data Redi
RedisTemplate使用最详解（三）--- opsForHash()
热门推荐
weixin_43658899的博客
10-31 5万+
1、put(H var1, HK var2, HV var3) 新增hashMap值 var1 为Redis的key var2 为key对应的map值的key var3 为key对应的map值的值 var2相同替换var3 redisTemplate.opsForHash().put("hashValue","map1","value1"); redisTemplate.opsForHash().put("hashValue","map2","value2"); 2、get(H var1, Ob
redisTemplate.opsForHash()【redis hash类型缓存类型使用配置】
dreaming9420的博客
12-01 4299
1.hashSet(String key, Object hashKey, Object value) /** * hash类型缓存放入 * * @param key 键 * @param hashKey 哈希键 * @param value 值 * @return true 成功 false 失败 */ public boolean hashSet(String key, Object hashKey, Obj
RedisTemplet opsForHash中方法使用说明
ppjsyw的博客
06-17 1万+
以下各方法皆来自于Redis的命令,命令详细介绍参考https://blog.csdn.net/ppjsyw/article/details/125087623hset key field value 参数说明 key:键名 hashKey:字段名 value:值 示例 2.设置多个field 相关命令 hset key field value [field value …] 说明 key:键名m:多个键值对的map 3.当field不存在时设置 相关命令 hsetnx key field val
RedisTemplate的踩坑现场
网易技术热爱者
11-02 4460
RedisTemplate是Spring封装的一个最常用的redis数据访问工具类，功能强大，使用简洁。但在RedisTemplate看似简单的API下，也是暗流涌动，背后别有一番洞天。本文从一个线上性能问题入手，抽丝剥茧一步步探索RedisTemplate，挖出了RedisTemplate操作psetex命令的深坑。
Java如何根据redis存放于hash中的小key做超时更新（基于RedisTemplate）
weixin_54925172的博客
08-23 520
如何基于RedisTemplate，对hash存值中的小key进行过期更新
Redis的简单使用补充1
一名码农的博客
09-05 985
redis的简单使用补充1
redisTemplate.boundHashOps("").put("","")乱码
weixin_44170566的博客
03-25 2947
解决办法 图中标注的红色部分如果不够用还可以自己加
redisTemplate.delete删除失败
记录
02-26 1万+
线上发现有缓存清楚失败的情况，线下模拟执行了下，发现redisTemplate.delete(key)返回false，网上查了下，说可能是set和delete用的不一致导致，比如set的时候用的，RedisTemplate<String, String>，而delete的时候用的RedisTemplate，确认在确定两边使用一致后，在delete前get了一下数据，发现是能获取到的。 最终找到的原因是，两边使用序列化不一致导致的，set的时候，使用的StringRedisS...
rediscachemanager redistemplate
09-06
RedisCacheManager是Spring Data Redis框架中的一个重要组件，用于管理Redis缓存的创建和管理。RedisCacheManager通过与Redis服务器进行交互，实现了数据的缓存与读取，并且具备一定的缓存策略。 RedisTemplate是...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值