spring boot 和spring data 整合redis tredistemplate和stringredistemplate常用方及其使用和bound...Ops的使用，快速入门

Knock-King

已于 2023-08-13 18:50:17 修改

阅读量328

点赞数 2

文章标签： spring redis 笔记后端 java

于 2023-08-13 18:48:41 首次发布

本文链接：https://blog.csdn.net/qq_62357662/article/details/132262938

版权

1. 概述

Spring Boot Data(数据) Redis中提供了RedisTemplate和StringRedisTemplate，其中StringRedisTemplate是RedisTemplate的子类，两个方法基本一致，不同之处主要体现在操作的数据类型不同,RedisTemplate中的两个泛型都是Object，意味着存储的key和value都可以是一个对象，而StringRedisTemplate的两个泛型都是String，意味着stringRedisTemplate的key和value都只能是字符串。

RedisTemplate(object,object): 自动序列化﹑自动反序列化

stringRedisTemplate (String,String)

注意:使用RedisTemplate默认是将对象序列化到Redis中,所以放入的对象必须实现对象序列化接口

2. 基本准备工作

2.1添加依赖

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

2.2 配置文件

# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-idle=8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=-1
# 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.jedis.timeout=5000

3. StringRedisTemplate

注入stringRedisTemplate

@Autowired
StringRedisTemplate stringRedisTemplate;

3.1 opsForValue-操作字符串（String）

string是redis中最基本的数据类型，一个key对应一个value

string类型是二进制安全的，即可以包含任何数据，包括数字、jpg图片或者序列化对象甚至是一张图片，最大512M

常用方法

//set(K key, V value) --新增一个字符串类型的值,key是键，value是值。
stringRedisTemplate.opsForValue().set("aaa","bbb"); 

//set(K key, V value, long timeout, TimeUnit unit) --设置变量值的过期时间。
//unit 过期时间单位取值如下：
	//DAYS：天时间单元代表24小时
	//HOURS：小时时间单元代表60分钟
	//MICROSECONDS：微秒时间单元代表千分之一毫秒
	//MILLISECONDS：毫秒时间单元代表千分之一秒
	//MINUTES：分钟时间单元代表60秒
	//NANOSECONDS：纳秒时间单元代表千分之一微秒
	//SECONDS：时间单元代表1秒
stringRedisTemplate.opsForValue().set("Key", "timeOut", 5, TimeUnit.SECONDS);  

//set(K key, V value, long offset) --覆盖从指定位置开始的值。
stringRedisTemplate.opsForValue().set("Key","dd",1);

//get(Object key) --根据键获取值;
String Value = stringRedisTemplate.opsForValue().get("key");

//get(K key, long start, long end) --截取key键对应值的字符串，从开始下标位置开始到结束下标的位置(包含结束下标)的字符串
stringRedisTemplate.opsForValue().get("stringkey", 2, 3);//若value-->al

//append(K key, String value) --在原有的值基础上新增字符串到末尾
stringRedisTemplate.opsForValue().append("key", "appendValue");

//getAndSet(K key, V value) --获取原来key键对应的值，并且重新赋新值。
String oldAndNewStringValue = stringRedisTemplate.opsForValue().getAndSet("key", "ccc");  

//size(K key) --获取指定字符串的长度
Long stringValueLength = stringRedisTemplate.opsForValue().size("key");  

//increment(K key, double delta) --以增量的方式将double值存储在变量中,相当于一个计数器（计算 +）。
//Redis Incr 命令将 key 中储存的数字值增一。
//如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。
//如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
//本操作的值限制在 64 位(bit)有符号数字表示之内。
double stringValueDouble = stringRedisTemplate.opsForValue().increment("doubleKey",3); 
Long stringValueDouble = stringRedisTemplate.opsForValue().increment("doubleKey",3);

//setIfAbsent(K key, V value) --如果键不存在则新增,存在则不改变已经有的值。
boolean absentBoolean = stringRedisTemplate.opsForValue().setIfAbsent("absentKey","aaaa"); 

//multiSet(Map<? extends K,? extends V> map) --设置map集合到redis。
Map valueMap = new HashMap();  
valueMap.put("value1","map1");  
valueMap.put("value2","map2");  
valueMap.put("value3","map3");  
stringRedisTemplate.opsForValue().multiSet(valueMap);  

//multiSetIfAbsent(Map<? extends K, ? extends V> map) --若原先已经存在key,map集合中的key与之前一样，value设置的不一样,value还是原先的值，不变
Map map1 = new HashMap();
       map1.put("value1", "map11");
       map1.put("value2", "map22");
       map1.put("value3", "map33");
       List list1 = new ArrayList();
       list1.add("value1");
       list1.add("value2");
       list1.add("value2");
       stringRedisTemplate.opsForValue().multiSetIfAbsent(map1);
       List<String> valueList1 = stringRedisTemplate.opsForValue().multiGet(list1);
       for (String value1 : valueList1) {
           System.out.println( value1);
       }
//输出 map1，map2，map3

//multiGet(Collection keys) --根据集合取出对应的value值。
//根据List集合取出对应的value值  
List list = new ArrayList();  
list.add("value1");  
list.add("value2");  
list.add("value3");  
List<String> valueList = stringRedisTemplate.opsForValue().multiGet(list);  
//list可以替换为Arrays.asList("value1","value2","value3")

//Boolean setBit(K key, long offset, boolean value) --key键对应的值value对应的ascii码,在offset的位置(从左向右数)变为value
//Boolean getBit(K key, long offset) --判断指定的位置ASCII码的bit位是否为true或者false
stringRedisTemplate.opsForValue().set("stringkey", "value");
stringRedisTemplate.opsForValue().setBit("stringkey", 1, true);
boolean flag= stringRedisTemplate.opsForValue().getBit("stringkey", 1);

//decrement(k key) --获取指定key的值进行减1，如果value不是integer类型，会抛异常，如果key不存在会创建一个，默认value为0
stringRedisTemplate.opsForValue().decrement("test2");

//delete(k key) --删除指定key,成功返回true，否则false
Boolean delete = stringRedisTemplate.opsForValue().getOperations().delete("test1");

//delete(k ...keys) --删除多个key，返回删除key的个数
Long delete = stringRedisTemplate.opsForValue().getOperations().delete(Arrays.asList("test1", "test2"));

3.2 opsForList-操作集合(List)

list其实就是链表，redis的底层是用双向链表实现的list，是有序的，value可重复的，可以通过下标取出对应的value值，左右两边都可以插入和删除数据。

常用方法

//leftPush(K key, V value) --在变量左边添加元素值。如果key不存在会新建，添加成功返回添加后的总个数
Long aLong = stringRedisTemplate.opsForList().leftPush("list", "a");

//leftPushAll(K key, V... values) --向左边批量添加参数元素，如果key不存在会新建，添加成功返回添加后的总个数
Long pushAll = stringRedisTemplate.opsForList().leftPushAll("list", "b", "a", "d");


//rightPush(K key, V value) --向集合最右边添加元素。如果key不存在会新建，添加成功返回添加后的总个数
Long aLong = stringRedisTemplate.opsForList().rightPush("list2", "a");

//rightPushAll(K key, V... values) --向右边批量添加元素。返回当前集合元素总个数        
Long aLong = stringRedisTemplate.opsForList().rightPushAll("list2", "b", "c", "d");

//leftPushIfPresent(K key, V value) --如果存在集合则添加元素。
Long aLong = stringRedisTemplate.opsForList().leftPushIfPresent("list", "h");

//rightPushIfPresent(K key, V value) --向已存在的集合中添加元素。返回集合总元素个数
Long aLong = stringRedisTemplate.opsForList().rightPushIfPresent("list", "e");

//size(K key) --获取集合长度
Long size = stringRedisTemplate.opsForList().size("list2");

//leftPop(K key) --移除集合中的左边第一个元素。返回删除的元素，如果元素为空，该集合会自动删除
String pop = stringRedisTemplate.opsForList().leftPop("list2");

//leftPop(K key, long timeout, TimeUnit unit) --移除集合中左边的元素在等待的时间里，如果超过等待的时间仍没有元素则退出。
String pop = stringRedisTemplate.opsForList().leftPop("list2", 10, TimeUnit.SECONDS);

//rightPop(K key) --移除集合中右边的元素。返回删除的元素，如果元素为空，该集合会自动删除
String pop = stringRedisTemplate.opsForList().rightPop("list2");

//rightPop(K key, long timeout, TimeUnit unit) --移除集合中右边的元素在等待的时间里，如果超过等待的时间仍没有元素则退出。
String pop = stringRedisTemplate.opsForList().rightPop("list2", 10, TimeUnit.SECONDS);

//rightPopAndLeftPush(K sourceKey, K destinationKey) -- 移除第一个集合右边的一个元素，插入第二个集合左边插入这个元素
String s = stringRedisTemplate.opsForList().rightPopAndLeftPush("list2", "list3");
        
//set(K key, long index, V value)--在集合的指定位置插入元素,如果指定位置已有元素，则覆盖，没有则新增，超过集合下标+n则会报错。
stringRedisTemplate.opsForList().set("list2", 2, "w");

//remove(K key, long count, Object value) --从存储在键中的列表中删除等于值的元素的第一个计数事件。count> 0：删除等于从左到右移动的值的第一个元素；count< 0：删除等于从右到左移动的值的第一个元素；count = 0：删除等于value的所有元素
Long remove = stringRedisTemplate.opsForList().remove("list2", 2, "w");
        
//trim(K key, long start, long end) --截取集合元素长度，保留长度内的数据。
stringRedisTemplate.opsForList().trim("list2", 0, 3);

//index(K key, long index) --获取集合指定位置的值。
Object listValue = stringRedisTemplate.opsForList().index("list2", 3);

//range(K key, long start, long end) --获取指定区间的值。
List<String> list = stringRedisTemplate.opsForList().range("list", 0, -1);

//delete(K key) --删除指定集合,返回true删除成功
Boolean delete = stringRedisTemplate.opsForList().getOperations().delete("list2");

3.3 opsForHash-操作集合(hashMap)

hash是一个string 类型的field和value的映射表。

hash特别适合存储对象。相对于将对象的每个字段存成单个string 类型。一个对象存储在hash类型中会占用更少的内存，并且可以更方便的存取整个对象。

Redis的Hash数据类型的value内部是一个HashMap,如果该Map的成员比较少，则会采用一维数组的方式来紧凑存储该Map，省去了大量指针的内存开销。

常用方法

//put(H key, HK hashKey, HV value) --新增hashMap值
stringRedisTemplate.opsForHash().put("hash","hash-key","hash-value");

//putAll(H key, Map<? extends HK,? extends HV> m) --以map集合的形式添加键值对
Map<String, String> map = new HashMap<>(16);
map.put("hash-key3", "value3");
map.put("hash-key4", "value4");
stringRedisTemplate.opsForHash().putAll("hash", map);


//putIfAbsent(H key, HK hashKey, HV value) --如果变量值存在，在变量中可以添加不存在的的键值对，如果变量不存在，则新增一个变量，同时将键值对添加到该变量。添加成功返回true否则返回false
Boolean absent = stringRedisTemplate.opsForHash().putIfAbsent("hash", "hash-key", "value1");
Boolean absent2 = stringRedisTemplate.opsForHash().putIfAbsent("hash", "hash-key5", "value5");
  
//values(H Key) --获取指定变量中的hashMap值。
List<Object> values = stringRedisTemplate.opsForHash().values("hash2");

//entries(H key) --获取变量中的键值对。
Map<Object, Object> entries = stringRedisTemplate.opsForHash().entries("hash");

//get(H key, Object hashKey) --获取变量中的指定map键是否有值,如果存在该map键则获取值，没有则返回null。
Object value = stringRedisTemplate.opsForHash().get("hash", "hash-key");
   
//keys(H key) -- 获取变量中的键。
Set<Object> keys = stringRedisTemplate.opsForHash().keys("hash");    
    
//size(H key) --获取变量的长度
Long size = stringRedisTemplate.opsForHash().size("hash");    

//increment(H key, HK hashKey, long data) --使变量中的键以long值的大小进行自增长。值必须为Integer类型,否则异常
Long increment = stringRedisTemplate.opsForHash().increment("hash", "hash-key2", 1);

//multiGet(H key, Collection<HK> hashKeys) --以集合的方式获取变量中的值。
List<Object> values = stringRedisTemplate.opsForHash().multiGet("hash", Arrays.asList("hash-key", "hash-key2"));   
   
//scan(H key, ScanOptions options) --匹配获取键值对，ScanOptions.NONE为获取全部键对，ScanOptions.scanOptions().match("hash-key2").build()匹配获取键位map1的键值对,不能模糊匹配。
Cursor<Map.Entry<Object, Object>> scan = stringRedisTemplate.opsForHash().scan("hash", ScanOptions.NONE);
        while (scan.hasNext()) {
            Map.Entry<Object, Object> next = scan.next();
            System.out.println(next.getKey() + "---->" + next.getValue());
        }

//delete(H key, Object... hashKeys) --删除变量中的键值对，可以传入多个参数，删除多个键值对。返回删除成功数量
Long delete = stringRedisTemplate.opsForHash().delete("hash", "hash-key", "hash-key1");

3.4 opsForSet-操作集合(set)

集合类型也是用来保存多个字符串的元素，但和列表不同的是集合中

不允许有重复的元素
集合中的元素是无序的，不能通过索引下标获取元素
支持集合间的操作，可以取多个集合取交集、并集、差集

常用方法


//add(K key, V... values) --向变量中批量添加值。返回添加的数量
Long add = stringRedisTemplate.opsForSet().add("set", "a", "b", "c");

//members(K key) -获取变量的值
Set<String> set = stringRedisTemplate.opsForSet().members("set");

//size(k key) --获取变量中值得长度
Long size = stringRedisTemplate.opsForSet().size("set");

//randomMember(k key) --随机获取变量中的某个元素
String member = stringRedisTemplate.opsForSet().randomMember("set");

//randomMembers(k key, long count) --随机获取变量中指定个数的元素
List<String> members = stringRedisTemplate.opsForSet().randomMembers("set", 2);
 
//isMember(k key, object value) --检查给定的元素是否在变量中,true为存在
Boolean member = stringRedisTemplate.opsForSet().isMember("set", "b");
  
//move(k key, v value, k targetKey) --转义变量的元素值到另一个变量中
Boolean move = stringRedisTemplate.opsForSet().move("set", "b", "set2");

//弹出变量中的元素。当元素全部弹完,变量也会删除 --pop(k key)
String pop = stringRedisTemplate.opsForSet().pop("set");

//remove(k key, v ...values) --批量删除变量中的元素,返回删除的数量
Long remove = stringRedisTemplate.opsForSet().remove("set2", "b");   

//scan(K key, ScanOptions options) --匹配获取键值对，ScanOptions.NONE为获取全部键值对；ScanOptions.scanOptions().match("C").build()匹配获取键位map1的键值对,不能模糊匹配。
Cursor<String> set = stringRedisTemplate.opsForSet().scan("set", ScanOptions.NONE);
        while (set.hasNext()) {
            String next = set.next();
            System.out.println(next);
        }

//difference(k key, k otherKey) --通过集合求差值。
Set<String> difference = stringRedisTemplate.opsForSet().difference("set", "set2");

//differenceAndStore(K key, K otherKey, K targetKey) --将求出来的差值元素保存
Long aLong = stringRedisTemplate.opsForSet().differenceAndStore("set", "set2", "set3");

//distinctRandomMembers(K key, long count) --获取去重的随机元素
Set<String> set = stringRedisTemplate.opsForSet().distinctRandomMembers("set", 2);

//intersect(K key, K otherKey) --获取两个变量中的交集
Set<String> intersect = stringRedisTemplate.opsForSet().intersect("set", "set2");

//intersectAndStore(K key, K otherKey, K targetKey)--获取2个变量交集后保存到最后一个变量上。
Long aLong = stringRedisTemplate.opsForSet().intersectAndStore("set", "set2", "set3");

//union(K key, K otherKey) --获取两个变量的合集
Set<String> union = stringRedisTemplate.opsForSet().union("set", "set2");

//unionAndStore(K key, K otherKey, K targetKey) --获取两个变量合集后保存到另一个变量中
Long aLong = stringRedisTemplate.opsForSet().unionAndStore("set", "set2", "set3");

3.5 opsForZset-操作集合(zset)

zset即Redis sorted set

Redis sorted set的使用场景与set类似，区别是set不是自动有序的，而sorted set可以通过用户额外提供一个优先级(score)的参数来为成员排序，并且是插入有序的，即自动排序。

可以理解为一列存 value,一列存顺序。操作中key理解为zset的名字.

当你需要一个有序的并且不重复的集合列表，那么可以选择sorted set数据结构

常用方法

//add(K key, V value, double score) --添加元素到变量中同时指定元素的分值。
Boolean add = stringRedisTemplate.opsForZSet().add("zset", "a", 1);

//add(K key, Set<ZSetOperations.TypedTuple<V>> tuples) --通过TypedTuple方式新增数据。
ZSetOperations.TypedTuple<String> typedTuple1 = new DefaultTypedTuple<>("E", 2.0);
        ZSetOperations.TypedTuple<String> typedTuple2 = new DefaultTypedTuple<>("F", 3.0);
        ZSetOperations.TypedTuple<String> typedTuple3 = new DefaultTypedTuple<>("G", 5.0);
        Set<ZSetOperations.TypedTuple<String>> typedTupleSet = new HashSet<>();
        typedTupleSet.add(typedTuple1);
        typedTupleSet.add(typedTuple2);
        typedTupleSet.add(typedTuple3);
        Long zset = stringRedisTemplate.opsForZSet().add("zset", typedTupleSet);
        System.out.println(zset);

//range(k key, long start, long end) --获取指定区间的元素
Set<String> zset = stringRedisTemplate.opsForZSet().range("zset", 0, -1);

//rangeByLex(K key, RedisZSetCommands.Range range) --用于获取满足非score的排序取值。这个排序只有在有相同分数的情况下才能使用，如果有不同的分数则返回值不确定。
Set<String> rangeByLex=stringRedisTemplate.opsForZSet().rangeByLex("zset",RedisZSetCommands.Range.range().lt("E"));

//rangeByLex(k key, range range, limit limit) --用于获取满足非score的设置下标开始的长度排序取值。
Set<String> zset = stringRedisTemplate.opsForZSet().rangeByLex("zset", RedisZSetCommands.Range.range().lt("E"),
                RedisZSetCommands.Limit.limit().offset(1).count(2));

//rangeByScore(K key, double min, double max) --根据设置的score获取区间值。
Set<String> zset = stringRedisTemplate.opsForZSet().rangeByScore("zset", 1, 3);

//rangeWithScores(K key, long start, long end) --获取RedisZSetCommands.Tuples的区间值。
Set<ZSetOperations.TypedTuple<String>> zset = stringRedisTemplate.opsForZSet().rangeWithScores("zset", 1, 3);
assert zset != null;
     for (ZSetOperations.TypedTuple<String> next : zset) {
            String value = next.getValue();
            Double score = next.getScore();
            System.out.println(value + "-->" + score);
        }

//count(k key, double min, double max) --获取区间值的个数。
Long zset = stringRedisTemplate.opsForZSet().count("zset", 1, 3);

//rank(k key, object o) --获取变量中指定元素的索引,下标开始为0
Long rank = stringRedisTemplate.opsForZSet().rank("zset", "a");


//scan(K key, ScanOptions options) --匹配获取键值对，ScanOptions.NONE为获取全部键值对；ScanOptions.scanOptions().match("C").build()匹配获取键位map1的键值对,不能模糊匹配。
Cursor<ZSetOperations.TypedTuple<String>> zset = stringRedisTemplate.opsForZSet().scan("zset", ScanOptions.NONE);
        while (zset.hasNext()) {
            ZSetOperations.TypedTuple<String> next = zset.next();
            System.out.println(next.getValue() + "-->" + next.getScore());
        }

//score(k key, object o) --获取指定元素的分值
Double score = stringRedisTemplate.opsForZSet().score("zset", "a");

//zCard(k key) --获取变量中元素的个数
Long zset = stringRedisTemplate.opsForZSet().zCard("zset");

//incrementScore(K key, V value, double delta) --修改变量中元素的分值
Double score = stringRedisTemplate.opsForZSet().incrementScore("zset", "a", 2);

//reverseRange(K key, long start, long end) --索引倒序排列指定区间的元素
Set<String> zset = stringRedisTemplate.opsForZSet().reverseRange("zset", 1, 3);

//reverseRangeByScore(K key, double min, double max) --倒序排列指定分值区间的元素
Set<String> zset = stringRedisTemplate.opsForZSet().reverseRangeByScore("zset", 1, 3);

//reverseRangeByScore(K key, double min, double max, long offset, long count) --倒序排序获取RedisZSetCommands.Tuples的分值区间值
Set<String> zset = stringRedisTemplate.opsForZSet().reverseRangeByScore("zset", 1, 3, 1, 2);

//reverseRangeByScoreWithScores(K key, double min, double max) --倒序排序获取RedisZSetCommands.Tuples的分值区间值。
Set<ZSetOperations.TypedTuple<String>> zset = stringRedisTemplate.opsForZSet().reverseRangeByScoreWithScores("zset", 1, 5);
ssert zset != null;
zset.iterator().forEachRemaining(e-> System.out.println(e.getValue() + "--->" + e.getScore()));

//reverseRank(k key, object o) --获取倒序排列的索引值
Long aLong = stringRedisTemplate.opsForZSet().reverseRank("zset", "a");

//intersectAndStore(K key, K otherKey, K destKey) --获取2个变量的交集存放到第3个变量里面。
Long aLong = stringRedisTemplate.opsForZSet().intersectAndStore("zset", "zset2", "zset3");

//unionAndStore(K key, K otherKey, K destKey) --获取2个变量的合集存放到第3个变量里面。 返回操作的数量
Long aLong = stringRedisTemplate.opsForZSet().unionAndStore("zset", "zset2", "zset3");

//remove(K key, Object... values) --批量移除元素根据元素值。返回删除的元素数量
Long remove = stringRedisTemplate.opsForZSet().remove("zset", "a", "b");
  
//removeRangeByScore(k key, double min, double max) --根据分值移除区间元素。返回删除的数量
Long zset = stringRedisTemplate.opsForZSet().removeRangeByScore("zset", 1, 3);

//removeRange(K key, long start, long end) --根据索引值移除区间元素。返回移除的元素集合
Set<String> zset = stringRedisTemplate.opsForZSet().reverseRange("zset", 0, 4);

4. RedisTemplate

因为StringRedisTemplate继承RedisTemplate。所以StringRedisTemplate里有的方法，RedisTemplate里面基本上也有。

参考StringRedisTemplate方法

注意:使用RedisTemplate默认是将对象序列化到Redis中,所以放入的对象必须实现对象序列化接口

4.1 解决RedisTemplate中key值序列化问题

在SpringBoot的RedisTemplate在redis当中存入数据的时候，能看到key和value被序列化，我们基本上很难判断这个缓存是干什么用的，我们都是key–>String,value–>object。

在config包中新建RedisConfig类

添加代码

@Configuration
public class RedisConfig {
    @Bean("strKeyRedisTemplate")
    public RedisTemplate<Object, Object> strKeyRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<Object, Object>();
        template.setConnectionFactory(redisConnectionFactory);
        RedisSerializer<String> stringRedisSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringRedisSerializer);
        return template;
    }
}

使用自定义序列化的RedisTemplate

    @Resource(name = "strKeyRedisTemplate")
    private RedisTemplate<Object,Object> strKeyRedisTemplate;

4.2 解决RedisTemplate中 hash 类型key值序列化问题

在RedisTemplate中hash类型中的key值也是被序列化了的，导致获取只能通过RedisTemplate调用方法。

在config包中新建RedisConfig类

添加代码

@Configuration
public class RedisConfig {
    @Bean("strKeyRedisTemplate")
    public RedisTemplate<Object, Object> strKeyRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<Object, Object>();
        template.setConnectionFactory(redisConnectionFactory);
        RedisSerializer<String> stringRedisSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringRedisSerializer);
        template.setHashKeySerializer(stringRedisSerializer)
        return template;
    }
}

使用自定义序列化的RedisTemplate

   @Resource(name = "strKeyRedisTemplate")
    private RedisTemplate<Object,Object> strKeyRedisTemplate;

4.3 序列化的方法

JdkSerializationRedisSerializer：POJO对象的存取场景，使用JDK本身序列化机制，将pojo类通过ObjectInputStream/ObjectOutputStream进行序列化操作，最终redis-server中将存储字节序列。是目前默认的序列化策略。
StringRedisSerializer：Key或者value为字符串的场景，根据指定的charset对数据的字节序列编码成string，是“new String(bytes, charset)”和“string.getBytes(charset)”的直接封装。是最轻量级和高效的策略。
JacksonJsonRedisSerializer：jackson-json工具提供了javabean与json之间的转换能力，可以将pojo实例序列化成json格式存储在redis中，也可以将json格式的数据转换成pojo实例。因为jackson工具在序列化和反序列化时，需要明确指定Class类型，因此此策略封装起来稍微复杂。【需要jackson-mapper-asl工具支持】
GenericFastJsonRedisSerializer：另一种javabean与json之间的转换，同时也需要指定Class类型。
OxmSerializer：提供了将javabean与xml之间的转换能力，目前可用的三方支持包括jaxb，apache-xmlbeans；redis存储的数据将是xml工具。不过使用此策略，编程将会有些难度，而且效率最低；不建议使用。【需要spring-oxm模块的支持】
FastJsonRedisSerializer：使用 Alibaba Fastjson 处理。

5. bound…Ops

bound…Ops就是一个绑定key的对象，我们可以通过这个对象来进行与key相关的操作。操作完全和上面一样，就是用bound…Ops，关于这个key的一系列的操作都可以使用这个对象，避免代码冗余，重复

其中就有：

oundValueOperations ----string
BoundHashOperations ----hash
BoundListOperations ----list
BoundSetOperations ----set
BoundZSetOperations ----zset

例如

BoundHashOperations boundHashOps = redisTemplate.boundHashOps("user");
boundHashOps.put("lcy","柳成荫"); //---相当于 redisTemplate.opsForHash.put("lcy","柳成荫");
boundHashOps.put("jyqc","九月清晨");
boundHashOps.get("jyqc")

6.总结

当你的redis数据库里面本来存的是字符串数据或者你要存取的数据就是字符串类型数据的时候，那么你就使用StringRedisTemplate即可

但是如果你的数据是复杂的对象类型，而取出的时候又不想做任何的数据转换，直接从Redis里面取出一个对象，那么使用RedisTemplate是更好的选择。

Knock-King

关注

2
点赞
踩
3

收藏

觉得还不错? 一键收藏
1
评论
spring boot 和spring data 整合redis tredistemplate和stringredistemplate常用方及其使用和bound...Ops的使用，快速入门

当你的redis数据库里面本来存的是字符串数据或者你要存取的数据就是字符串类型数据的时候，那么你就使用StringRedisTemplate即可但是如果你的数据是复杂的对象类型，而取出的时候又不想做任何的数据转换，直接从Redis里面取出一个对象，那么使用RedisTemplate是更好的选择。
复制链接

扫一扫