RedisTemplate操作Redis

已于 2022-08-11 09:51:28 修改
阅读量966 收藏
点赞数
分类专栏： Redis 文章标签： Redis Template
于 2022-08-11 09:48:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhezhe_9860/article/details/126279143
版权

一、SpringDataRedis简介

1、Redis

redis是一款开源的key-value数据库，运行在内存中，由C语言编写。企业开发通常采用Redis来实现缓存。同类的产品还有memcache 、memcached 。

和Memcached类似，Redis支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set – 有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，这些操作都是原子性的。

2、Jedis

Jedis是Redis官方推出的一款面向Java的客户端，提供了很多接口供Java语言调用。可以在Redis官网下载，当然还有一些开源爱好者提供的客户端，如Jredis、SRP等等，推荐使用Jedis。

3、Spring Data Redis

Spring-data-redis是spring大家族的一部分，提供了在srping应用中通过简单的配置访问redis服务，对reids底层开发包(Jedis, JRedis, and RJC)进行了高度封装，RedisTemplate提供了redis各种操作、异常处理及序列化，支持发布订阅，并对spring 3.1 cache进行了实现。
spring-data-redis针对jedis提供了如下功能：

1.连接池自动管理，提供了一个高度封装的“RedisTemplate”类

2.针对jedis客户端中大量api进行了归类封装,将同一类型操作封装为operation接口

  • ValueOperations：简单K-V操作
  • SetOperations：set类型数据操作
  • ZSetOperations：zset类型数据操作
  • HashOperations：针对map类型的数据操作
  • ListOperations：针对list类型的数据操作

3. 提供了对key的“bound”(绑定)便捷化操作API，可以通过bound封装指定的key，然后进行一系列的操作而无须“显式”的再次指定Key，即BoundKeyOperations：

  • BoundValueOperations
  • BoundSetOperations
  • BoundListOperations
  • BoundSetOperations
  • BoundHashOperations

4.将事务操作封装，有容器控制。

5.针对数据的“序列化/反序列化”，提供了多种可选择策略(RedisSerializer)

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工具支持)。

二、RedisTemplate中API使用

1、pom.xml依赖

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

2、配置文件

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

3、RedisTemplate的直接方法

首先使用@Autowired注入RedisTemplate（后面直接使用，就不特殊说明）

@Autowired
private RedisTemplate redisTemplate;

1)、删除单个key

//删除一个key
public void delete(String key){
    redisTemplate.delete(key);
}

2)、删除多个key

//删除多个key
public void deleteKey (String ...keys){
    redisTemplate.delete(keys);
}

3)、指定key的失效时间

//指定key的失效时间
public void expire(String key,long time){
    redisTemplate.expire(key,time,TimeUnit.MINUTES);
}

4)、根据key获取过期时间

//根据key获取过期时间
public long getExpire(String key){
    Long expire = redisTemplate.getExpire(key);
    return expire;
}

5)、判断key是否存在

//判断key是否存在
public boolean hasKey(String key){
    return redisTemplate.hasKey(key);
}

4、String类型相关操作

1)、添加缓存

//1、通过redisTemplate设置值
redisTemplate.boundValueOps("StringKey").set("StringValue");
redisTemplate.boundValueOps("StringKey").set("StringValue",1, TimeUnit.MINUTES);

//2、通过BoundValueOperations设置值
BoundValueOperations stringKey = redisTemplate.boundValueOps("StringKey");
stringKey.set("StringVaule");
stringKey.set("StringValue",1, TimeUnit.MINUTES);

//3、通过ValueOperations设置值
ValueOperations ops = redisTemplate.opsForValue();
ops.set("StringKey", "StringVaule");
ops.set("StringValue","StringVaule",1, TimeUnit.MINUTES);

2)、设置过期时间(单独设置)

redisTemplate.boundValueOps("StringKey").expire(1,TimeUnit.MINUTES);
redisTemplate.expire("StringKey",1,TimeUnit.MINUTES);

3)、获取缓存值

//1、通过redisTemplate设置值
String str1 = (String) redisTemplate.boundValueOps("StringKey").get();

//2、通过BoundValueOperations获取值
BoundValueOperations stringKey = redisTemplate.boundValueOps("StringKey");
String str2 = (String) stringKey.get();

//3、通过ValueOperations获取值
ValueOperations ops = redisTemplate.opsForValue();
String str3 = (String) ops.get("StringKey");

4)、删除key

Boolean result = redisTemplate.delete("StringKey");

5)、顺序递增

redisTemplate.boundValueOps("StringKey").increment(3L);

6)、顺序递减

redisTemplate.boundValueOps("StringKey").increment(-3L);

5、Hash类型相关操作

1)、添加缓存

//1、通过redisTemplate设置值
redisTemplate.boundHashOps("HashKey").put("SmallKey", "HashVaue");

//2、通过BoundValueOperations设置值
BoundHashOperations hashKey = redisTemplate.boundHashOps("HashKey");
hashKey.put("SmallKey", "HashVaue");

//3、通过ValueOperations设置值
HashOperations hashOps = redisTemplate.opsForHash();
hashOps.put("HashKey", "SmallKey", "HashVaue");

2)、设置过期时间(单独设置)

redisTemplate.boundValueOps("HashKey").expire(1,TimeUnit.MINUTES);
redisTemplate.expire("HashKey",1,TimeUnit.MINUTES);

3)、添加一个Map集合

HashMap<String, String> hashMap = new HashMap<>();
redisTemplate.boundHashOps("HashKey").putAll(hashMap );

4)、设置过期时间(单独设置)

redisTemplate.boundValueOps("HashKey").expire(1,TimeUnit.MINUTES);
redisTemplate.expire("HashKey",1,TimeUnit.MINUTES);

5)、提取所有的小key

//1、通过redisTemplate获取值
Set keys1 = redisTemplate.boundHashOps("HashKey").keys();

//2、通过BoundValueOperations获取值
BoundHashOperations hashKey = redisTemplate.boundHashOps("HashKey");
Set keys2 = hashKey.keys();

//3、通过ValueOperations获取值
HashOperations hashOps = redisTemplate.opsForHash();
Set keys3 = hashOps.keys("HashKey");

6)、提取所有的value值

//1、通过redisTemplate获取值
List values1 = redisTemplate.boundHashOps("HashKey").values();

//2、通过BoundValueOperations获取值
BoundHashOperations hashKey = redisTemplate.boundHashOps("HashKey");
List values2 = hashKey.values();

//3、通过ValueOperations获取值
HashOperations hashOps = redisTemplate.opsForHash();
List values3 = hashOps.values("HashKey");

7)、根据key提取value值

//1、通过redisTemplate获取
String value1 = (String) redisTemplate.boundHashOps("HashKey").get("SmallKey");

//2、通过BoundValueOperations获取值
BoundHashOperations hashKey = redisTemplate.boundHashOps("HashKey");
String value2 = (String) hashKey.get("SmallKey");

//3、通过ValueOperations获取值
HashOperations hashOps = redisTemplate.opsForHash();
String value3 = (String) hashOps.get("HashKey", "SmallKey");

8)、获取所有的键值对集合

//1、通过redisTemplate获取
Map entries = redisTemplate.boundHashOps("HashKey").entries();

//2、通过BoundValueOperations获取值
BoundHashOperations hashKey = redisTemplate.boundHashOps("HashKey");
Map entries1 = hashKey.entries();

//3、通过ValueOperations获取值
HashOperations hashOps = redisTemplate.opsForHash();
Map entries2 = hashOps.entries("HashKey");

9)、删除

//删除小key
redisTemplate.boundHashOps("HashKey").delete("SmallKey");
//删除大key
redisTemplate.delete("HashKey");

10)、判断Hash中是否含有该值

Boolean isEmpty = redisTemplate.boundHashOps("HashKey").hasKey("SmallKey");

6、Set类型相关操作

1)、添加Set缓存(值可以是一个，也可是多个)(2/3是1的递进值）

//1、通过redisTemplate设置值
redisTemplate.boundSetOps("setKey").add("setValue1", "setValue2", "setValue3");

//2、通过BoundValueOperations设置值
BoundSetOperations setKey = redisTemplate.boundSetOps("setKey");
setKey.add("setValue1", "setValue2", "setValue3");

//3、通过ValueOperations设置值
SetOperations setOps = redisTemplate.opsForSet();
setOps.add("setKey", "SetValue1", "setValue2", "setValue3");

2)、设置过期时间(单独设置)

redisTemplate.boundValueOps("setKey").expire(1,TimeUnit.MINUTES);
redisTemplate.expire("setKey",1,TimeUnit.MINUTES);

3)、根据key获取Set中的所有值

//1、通过redisTemplate获取值
Set set1 = redisTemplate.boundSetOps("setKey").members();

//2、通过BoundValueOperations获取值
BoundSetOperations setKey = redisTemplate.boundSetOps("setKey");
Set set2 = setKey.members();

//3、通过ValueOperations获取值
SetOperations setOps = redisTemplate.opsForSet();
Set set3 = setOps.members("setKey");

4)、根据value从一个set中查询,是否存在

Boolean isEmpty = redisTemplate.boundSetOps("setKey").isMember("setValue2");

5)、获取Set缓存的长度

Long size = redisTemplate.boundSetOps("setKey").size();

6)、移除指定的元素

Long result1 = redisTemplate.boundSetOps("setKey").remove("setValue1");

7)、移除指定的key

Boolean result2 = redisTemplate.delete("setKey");

7、 LIST类型相关操作

1)、添加缓存（2/3是1的递进值）

//1、通过redisTemplate设置值
redisTemplate.boundListOps("listKey").leftPush("listLeftValue1");
redisTemplate.boundListOps("listKey").rightPush("listRightValue2");

//2、通过BoundValueOperations设置值
BoundListOperations listKey = redisTemplate.boundListOps("listKey");
listKey.leftPush("listLeftValue3");
listKey.rightPush("listRightValue4");

//3、通过ValueOperations设置值
ListOperations opsList = redisTemplate.opsForList();
opsList.leftPush("listKey", "listLeftValue5");
opsList.rightPush("listKey", "listRightValue6");

2)、将List放入缓存

ArrayList<String> list = new ArrayList<>();
redisTemplate.boundListOps("listKey").rightPushAll(list);
redisTemplate.boundListOps("listKey").leftPushAll(list);

3)、设置过期时间(单独设置)

redisTemplate.boundValueOps("listKey").expire(1,TimeUnit.MINUTES);
redisTemplate.expire("listKey",1,TimeUnit.MINUTES);

4)、获取List缓存全部内容（起始索引，结束索引）

List listKey1 = redisTemplate.boundListOps("listKey").range(0, 10);

5)、从左或从右弹出一个元素

String listKey2 = (String) redisTemplate.boundListOps("listKey").leftPop();  
//从左侧弹出一个元素
String listKey3 = (String) redisTemplate.boundListOps("listKey").rightPop(); 
//从右侧弹出一个元素

6)、根据索引查询元素

String listKey4 = (String) redisTemplate.boundListOps("listKey").index(1);

7)、获取List缓存的长度

Long size = redisTemplate.boundListOps("listKey").size();

8)、根据索引修改List中的某条数据(key，索引，值)

redisTemplate.boundListOps("listKey").set(3L,"listLeftValue3");

9)、移除N个值为value(key,移除个数，值)

redisTemplate.boundListOps("listKey").remove(3L,"value");

8、Zset类型的相关操作

1)、向集合中插入元素，并设置分数
//1、通过redisTemplate设置值
redisTemplate.boundZSetOps("zSetKey").add("zSetVaule", 100D);

//2、通过BoundValueOperations设置值
BoundZSetOperations zSetKey = redisTemplate.boundZSetOps("zSetKey");
zSetKey.add("zSetVaule", 100D);

//3、通过ValueOperations设置值
ZSetOperations zSetOps = redisTemplate.opsForZSet();
zSetOps.add("zSetKey", "zSetVaule", 100D);

2)、向集合中插入多个元素,并设置分数

DefaultTypedTuple<String> p1 = new DefaultTypedTuple<>("zSetVaule1", 2.1D);
DefaultTypedTuple<String> p2 = new DefaultTypedTuple<>("zSetVaule2", 3.3D);
redisTemplate.boundZSetOps("zSetKey").add(new HashSet<>(Arrays.asList(p1,p2)));

3)、按照排名先后(从小到大)打印指定区间内的元素, -1为打印全部

Set<String> range = redisTemplate.boundZSetOps("zSetKey").range(0, -1);

4)、获得指定元素的分数

Double score = redisTemplate.boundZSetOps("zSetKey").score("zSetVaule");

5)、返回集合内的成员个数

Long size = redisTemplate.boundZSetOps("zSetKey").size();

6)、返回集合内指定分数范围的成员个数（Double类型）

Long COUNT = redisTemplate.boundZSetOps("zSetKey").count(0D, 2.2D);

7)、返回集合内元素在指定分数范围内的排名（从小到大）

Set byScore = redisTemplate.boundZSetOps("zSetKey").rangeByScore(0D, 2.2D);

8)、带偏移量和个数，(key，起始分数，最大分数，偏移量，个数)

Set<String> ranking2 = 
                   redisTemplate.opsForZSet().rangeByScore("zSetKey", 0D, 2.2D 1, 3);

9)、返回集合内元素的排名，以及分数（从小到大）

Set<TypedTuple<String>> tuples =                                                 redisTemplate.boundZSetOps("zSetKey").rangeWithScores(0L, 3L);
  for (TypedTuple<String> tuple : tuples) {
      System.out.println(tuple.getValue() + " : " + tuple.getScore());
  }

10)、返回指定成员的排名

//从小到大
Long startRank = redisTemplate.boundZSetOps("zSetKey").rank("zSetVaule");
//从大到小
Long endRank = redisTemplate.boundZSetOps("zSetKey").reverseRank("zSetVaule");

11)、从集合中删除指定元素

redisTemplate.boundZSetOps("zSetKey").remove("zSetVaule");

12)、删除指定索引范围的元素（Long类型）

redisTemplate.boundZSetOps("zSetKey").removeRange(0L,3L);

13)、删除指定分数范围内的元素（Double类型）

redisTemplate.boundZSetOps("zSetKey").removeRangeByScorssse(0D,2.2D);

14)、为指定元素加分（Double类型）

Double score = redisTemplate.boundZSetOps("zSetKey").incrementScore("zSetVaule",1.1D);

三、SpringBoot整合Redis—RedisTemplate

1、引入依赖

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

2、RedisTemplate五种数据结构的操作

redisTemplate.opsForValue(); //操作字符串
redisTemplate.opsForHash(); //操作hash
redisTemplate.opsForList(); //操作list
redisTemplate.opsForSet(); //操作set
redisTemplate.opsForZSet(); //操作有序zset
RedisTemplate方法讲解
判断key是否存在
 /**
     * 判断key是否存在
     */
    @GetMapping("haskey")
    public boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

3、获取指定的key的失效时间

 /**
     * 指定key的失效时间
     */
    @GetMapping("expire")
    public void expire(String key, long time) {
        //参数一：key
        //参数二：睡眠时间
        //参数三：睡眠时间单位 TimeUnit.DAYS 天 TimeUnit.HOURS 小时 。。。
        redisTemplate.expire(key, time, TimeUnit.MINUTES);
    }

4、key获取过期时间

/**
     * 根据key获取过期时间
     */
    @GetMapping("getexpire")
    public long getExpire(String key) {
        Long expire = redisTemplate.getExpire(key);
        return expire;
    }

5、根据key删除reids中缓存数据

/**
     * 根据key删除reids中缓存数据
     */
    @GetMapping("delredisbykey")
    public void delete(String key) {
        redisTemplate.delete(key);
    }

6、保存和读取String

/**
     * 保存和读取String
     */
@GetMapping("stringredisdemo")
public String stringredisdemo() {
	//设置过期时间为1分钟
    redisTemplate.opsForValue().set("key1", "value1", 1, TimeUnit.MINUTES);
    redisTemplate.opsForValue().set("key2", "value2");
    redisTemplate.opsForValue().set("key3", "value3");
    //读取redis数据
    String result1 = redisTemplate.opsForValue().get("key1").toString();
    String result2 = redisTemplate.opsForValue().get("key2").toString();
    String result3 = redisTemplate.opsForValue().get("key3").toString();
    System.out.println("缓存结果为：result：" + result1 + "  " + result2 + "   " + result3);
    return "缓存结果为：result：" + result1 + "  " + result2 + "   " + result3;
}

7、保存和读取list

/**
     * 保存和读取list
     */
@GetMapping("listredisdemo")
public String listredisdemo() {
    List<String> list1 = new ArrayList<>();
    list1.add("a1");
    list1.add("a2");
    list1.add("a3");
    List<String> list2 = new ArrayList<>();
    list2.add("b1");
    list2.add("b2");
    list2.add("b3");
    redisTemplate.opsForList().leftPush("listkey1", list1);
    redisTemplate.opsForList().rightPush("listkey2", list2);
    List<String> resultList1 = (List<String>) redisTemplate.opsForList().leftPop("listkey1");
    List<String> resultList2 = (List<String>) redisTemplate.opsForList().rightPop("listkey2");
    System.out.println("resultList1:" + resultList1);
    System.out.println("resultList2:" + resultList2);
    return "成功";
}

8、Hash结构，保存和读取map

 /**
     * Hash结构，保存和读取map
     */
    @GetMapping("mapredisdemo")
    public String mapredisdemo() {
        Map<String, String> map = new HashMap<>();
        map.put("key1", "value1");
        map.put("key2", "value2");
        map.put("key3", "value3");
        map.put("key4", "value4");
        map.put("key5", "value5");
        redisTemplate.opsForHash().putAll("map1", map);
        Map<String, String> resultMap = redisTemplate.opsForHash().entries("map1");
        List<String> reslutMapList = redisTemplate.opsForHash().values("map1");
        Set<String> resultMapSet = redisTemplate.opsForHash().keys("map1");
        String value = (String) redisTemplate.opsForHash().get("map1", "key1");
        System.out.println("value:" + value);
        System.out.println("resultMapSet:" + resultMapSet);
        System.out.println("resultMap:" + resultMap);
        System.out.println("resulreslutMapListtMap:" + reslutMapList);
        return "成功";
    }

9、保存和读取Set

/**
     * 保存和读取Set
     */
    @GetMapping("setredisdemo")
    public String getredisdemo() {
        SetOperations<String, String> set = redisTemplate.opsForSet();
        set.add("key1", "value1");
        set.add("key1", "value2");
        set.add("key1", "value3");
        Set<String> resultSet = redisTemplate.opsForSet().members("key1");
        System.out.println("resultSet:" + resultSet);
        return "resultSet:" + resultSet;
    }

10、保存和读取zset

/**
     * 保存和读取zset
     */
    @GetMapping("zsetredisdemo")
    public String zsetredisdemo() {
        ZSetOperations.TypedTuple<Object> objectTypedTuple1 = new DefaultTypedTuple<>("zset-5", 9.6);
        ZSetOperations.TypedTuple<Object> objectTypedTuple2 = new DefaultTypedTuple<>("zset-6", 9.9);
        Set<ZSetOperations.TypedTuple<Object>> tuples = new HashSet<>();
        tuples.add(objectTypedTuple1);
        tuples.add(objectTypedTuple2);
        System.out.println(redisTemplate.opsForZSet().add("zset1", tuples));
        System.out.println(redisTemplate.opsForZSet().range("zset1", 0, -1));
        return "成功";
    }

完整示例代码

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.DefaultTypedTuple;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

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

@RestController
public class ReidsDemo {

    @Autowired
    RedisTemplate redisTemplate;

    /**
     * 指定key的失效时间
     */
    @GetMapping("expire")
    public void expire(String key, long time) {
        //参数一：key
        //参数二：睡眠时间
        //参数三：睡眠时间单位 TimeUnit.DAYS 天 TimeUnit.HOURS 小时 。。。
        redisTemplate.expire(key, time, TimeUnit.MINUTES);
    }

    /**
     * 根据key获取过期时间
     */
    @GetMapping("getexpire")
    public long getExpire(String key) {
        Long expire = redisTemplate.getExpire(key);
        return expire;
    }

    /**
     * 判断key是否存在
     */
    @GetMapping("haskey")
    public boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 根据key删除reids中缓存数据
     */
    @GetMapping("delredisbykey")
    public void delete(String key) {
        redisTemplate.delete(key);
    }

    /**
     * 保存和读取String
     */
    @GetMapping("stringredisdemo")
    public String stringredisdemo() {
        //设置过期时间为1分钟
        redisTemplate.opsForValue().set("key1", "value1", 1, TimeUnit.MINUTES);
        redisTemplate.opsForValue().set("key2", "value2");
        redisTemplate.opsForValue().set("key3", "value3");
        //读取redis数据
        String result1 = redisTemplate.opsForValue().get("key1").toString();
        String result2 = redisTemplate.opsForValue().get("key2").toString();
        String result3 = redisTemplate.opsForValue().get("key3").toString();
        System.out.println("缓存结果为：result：" + result1 + "  " + result2 + "   " + result3);
        return "缓存结果为：result：" + result1 + "  " + result2 + "   " + result3;
    }

    /**
     * 保存和读取list
     */
    @GetMapping("listredisdemo")
    public String listredisdemo() {
        List<String> list1 = new ArrayList<>();
        list1.add("a1");
        list1.add("a2");
        list1.add("a3");
        List<String> list2 = new ArrayList<>();
        list2.add("b1");
        list2.add("b2");
        list2.add("b3");
        redisTemplate.opsForList().leftPush("listkey1", list1);
        redisTemplate.opsForList().rightPush("listkey2", list2);
        List<String> resultList1 = (List<String>) redisTemplate.opsForList().leftPop("listkey1");
        List<String> resultList2 = (List<String>) redisTemplate.opsForList().rightPop("listkey2");
        System.out.println("resultList1:" + resultList1);
        System.out.println("resultList2:" + resultList2);
        return "成功";
    }

    /**
     * Hash结构，保存和读取map
     */
    @GetMapping("mapredisdemo")
    public String mapredisdemo() {
        Map<String, String> map = new HashMap<>();
        map.put("key1", "value1");
        map.put("key2", "value2");
        map.put("key3", "value3");
        redisTemplate.opsForHash().putAll("map1", map);
        Map<String, String> resultMap = redisTemplate.opsForHash().entries("map1");
        List<String> reslutMapList = redisTemplate.opsForHash().values("map1");
        Set<String> resultMapSet = redisTemplate.opsForHash().keys("map1");
        String value = (String) redisTemplate.opsForHash().get("map1", "key1");
        System.out.println("value:" + value);
        System.out.println("resultMapSet:" + resultMapSet);
        System.out.println("resultMap:" + resultMap);
        System.out.println("resulreslutMapListtMap:" + reslutMapList);
        return "成功";
    }

    /**
     * 保存和读取Set
     */
    @GetMapping("setredisdemo")
    public String getredisdemo() {
        SetOperations<String, String> set = redisTemplate.opsForSet();
        set.add("key1", "value1");
        set.add("key1", "value2");
        set.add("key1", "value3");
        Set<String> resultSet = redisTemplate.opsForSet().members("key1");
        System.out.println("resultSet:" + resultSet);
        return "resultSet:" + resultSet;
    }

    /**
     * 保存和读取zset
     */
    @GetMapping("zsetredisdemo")
    public String zsetredisdemo() {
        ZSetOperations.TypedTuple<Object> objectTypedTuple1 = new DefaultTypedTuple<>("zset-5", 9.6);
        ZSetOperations.TypedTuple<Object> objectTypedTuple2 = new DefaultTypedTuple<>("zset-6", 9.9);
        Set<ZSetOperations.TypedTuple<Object>> tuples = new HashSet<>();
        tuples.add(objectTypedTuple1);
        tuples.add(objectTypedTuple2);
        System.out.println(redisTemplate.opsForZSet().add("zset1", tuples));
        System.out.println(redisTemplate.opsForZSet().range("zset1", 0, -1));
        return "成功";
    }

}

序列化

直接粘贴在项目中即可

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.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/*
*序列化
 */
@Configuration
public class MyRedisConfig {

    @Bean(name = "redisTemplate")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        //参照StringRedisTemplate内部实现指定序列化器
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.setKeySerializer(keySerializer());
        redisTemplate.setHashKeySerializer(keySerializer());
        redisTemplate.setValueSerializer(valueSerializer());
        redisTemplate.setHashValueSerializer(valueSerializer());
        return redisTemplate;
    }

    private RedisSerializer<String> keySerializer(){
        return new StringRedisSerializer();
    }

    //使用Jackson序列化器
    private RedisSerializer<Object> valueSerializer(){
        return new GenericJackson2JsonRedisSerializer();
    }
参考文章：

Redis CSDN文档: https://blog.csdn.net/lydms/article/details/105224210

文档2 springboot：https://ost.51cto.com/posts/2333

Redis命令： http://doc.redisfans.com/

孟哲Hogan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java操作Redis缓存设置过期时间的方法
08-19
主要介绍了java操作Redis缓存设置过期时间的方法,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
redis基础
梦想是很难很难的，所以先勇敢一点
04-19 467
redis是用c语言开发的一个开源的高性能键值对（key-value）非关系型数据库，基于内存也可持久化的数据库，相对于关系型数据库（数据主要存在硬盘中），性能高，因此我们一般用redis来做缓存使用官方提供测试数据，50个并发执行10万个请求，读的速度是11万次/s，写的速度是81000次/s且redis通过提供多种键值数据类型来适应不同场景下的存储需求key不要太长，最好不要超过1024个字节，这不仅会消耗内存还会降低查找效率key不要太短，如果太短会降低key的可读性。
redis学习-RedisTemplate和StringRedisTemplate，Template相关方法和命令在这基本能找到
RuiKe的博客
08-29 1157
stringRedisTemplate.opsForValue().set("test", "100",60*10,TimeUnit.SECONDS);//向redis里存入数据和设置缓存时间 stringRedisTemplate.opsForValue().get("test")//根据key获取缓存中的val stringRedisTemplate.boundValueOps("test")...
Redis工具类（redisTemplate）以及 redisTemplate 的用法
我认不到你的博客
07-08 2098
Redis工具类（redisTemplate）以及 redisTemplate 的用法
Spring Boot缓存实战 Redis 设置有效时间和自动刷新缓存
baidu_37366055的博客
11-12 4569
时间方式，直接扩展注解的Value值，如： @Override @Cacheable(value = "people#${select.cache.timeout:1800}#${select.cache.refresh:600}", key = "#person.id", sync = true) public Person findOne(Person person, String a, String[] b, List<Long> c) { Person p = personR
03，redisTemplate
w7635122886的博客
01-08 1117
redisTemplate
关于redis过期时间的问题
Xiaofeng_Lu__的博客
11-24 6308
1.多次修改一个redis的String过期键，如何保证他仍然能保留第一次设置时的删除时间 2.修改hash、set、hset、list的值，会使过期时间重置吗？ 2.修改hash的值，会使过期时间重置吗？
SpringBoot 自定义注解实现Redis缓存功能
招风的黑耳CSDN
05-05 1280
*** redis 缓存注解*//**缓存的key**//**缓存时长，默认-1表示永久有效**//**缓存时长单位，默认单位秒**//*** 自定义缓存处理*/@Aspect@Slf4j@Component@Autowired//判断是否开启缓存//缓存开关if(StringUtils.isNotEmpty(hckg) && "1".equals(hckg)) { //开启。
分享工作中的redis zset使用
Ivan_Lin blog
09-22 450
场景 Client端给我们平台（Platform）推送很多文件，需要我们平台将这些文件上传给Google。 实现方案 平台使用Mysql存储Client发来的file数据，然后通过upload server将文件上传给Google。 上面的传输方式有如下缺点 只有一台upload server，上传速度慢 万一upload server宕机，整个服务就挂了 使用物理机不利于服务迁移和后续扩展 改进方案 多个upload server并行上传文件，在平台...
Redis生成时间戳流水号
大话家的博客
12-30 1441
@Resource private RedisTemplate<String, Object> redisTemplate; /** * 获取序列号，生成复杂流水号，时间戳加末尾4位自增值，自增值每天都会重置为1，例如：OA_202112260001 */ public String getIncrement(String key) { // 获取时间戳 String timeStamp = DateUtil.format(new Date(), "yyyyMMdd"); // 拼.
spring使用RedisTemplate的操作类访问Redis
08-30
本篇文章主要介绍了spring使用RedisTemplate的操作类访问Redis，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Redis之RedisTemplate使用（RedisTemplate工具类）
03-15
Redis之RedisTemplate使用（RedisTemplate工具类） String类型相关操作 List类型相关操作 Set类型相关操作 Map类型相关操作 ZSet类型相关操作
RedisTemplate具体操作
04-26
RedisTemplate具体操作
RedisOperation，Redis操作工具类
最新发布
01-09
内容概要：主要把一些常用的redis操作使用redisTemplate包装为redis命令名的方式，包括redis各种数据类型的插入，获取方法，如，返回有序集key中，指定区间内的成员。且带有score； 返回有序集key中，所有score值...
spring-data-redis支持批量操作
11-08
1、基于1.8.0的基础上提供批量的数据操作包括get set del hmget hmset方法 2、使用方法如下： public List<V> pipelineGet(Set<K> keys){ return rt.opsForPipeline().get(keys); } public void pipelineSet...
Spring操作redis3.2文档.chm
04-06
谷歌翻译redis3.2文档
Java - Redis操作的工具类RedisUtil
12-13
内容概要：主要把一些常用的redis操作使用redisTemplate包装为redis命令名的方式，包括redis的各种数据类型的操作方法，如，批量删除key；序列化key；查找匹配的key；将当前数据库的 key 移动到给定的数据库 db 当中...
springboot整合Redis
08-09
Spring Data Redis中提供了一个高度封装的类：**RedisTemplate**，针对 Jedis 客户端中大量api进行了归类封装,将同一类型操作封装为operation接口，具体分类如下： - ValueOperations：简单K-V操作 - SetOperations...
redis事务回滚工具
05-24
1、目前支持链接redis的工具主要是Redisson、RedisTemplate、StringRedisTemplate，默认Redisson 2、进行回滚时需要考虑是否要进行查询前镜像，可以通过设置RedisTransactionCommonUtil的QUERY_PREV属性 3、需要使用...
如何使用RedisTemplate操作Redis？
10-12
使用RedisTemplate操作Redis需要进行以下步骤： 1. 配置RedisTemplate：在Spring配置文件中添加Redis连接配置，包括主机名、端口号、密码等信息。 2. 注入RedisTemplate：在需要使用Redis的类中，使用@Autowired...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值