Spring Boot中引入Redis使用RedisTemplate缓存数据、读取数据、opsForValue、opsForList、opsForHash方法使用说明_opsforcluster

Spring Boot 引入RedisTemplate

1. 添加 Redis 依赖 在 pom.xml 文件中添加 Redis 相关的依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
1
2
3
4

2. 配置 Redis 连接信息 在 application.properties（或 application.yml）文件中配置 Redis 的连接信息

spring.redis.host=你的redis地址
spring.redis.port=你的redis端口
spring.redis.password=你的redis密码
1
2
3

3. 创建 RedisTemplate Bean 在 Spring Boot 的配置类中创建 RedisTemplate Bean，并配置连接工厂、序列化方式等

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.StringRedisSerializer;

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new StringRedisSerializer());
        return template;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

4. 在代码中使用 RedisTemplate 通过注入 RedisTemplate 对象，即可在代码中使用 RedisTemplate 进行操作

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

@Service
public class MyService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public void setValue(String key, String value) {
        redisTemplate.opsForValue().set(key, value);
    }

    public String getValue(String key) {
        return (String) redisTemplate.opsForValue().get(key);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

直接@Autowired注入RedisTemplate和创建RedisTemplate Bean有什么区别？

• @Autowired private RedisTemplate redisTemplate;这种方式虽然简单，但是它使用的是默认的序列化方式（使用JdkSerializationRedisSerializer序列化），这样在存储非String类型的数据时，可能会遇到序列化问题。而且不同的业务逻辑会有不同的数据类型需求，如果一刀切地使用默认的序列化方式，可能会导致数据类型转化异常、存储数据出错等问题。

• 而创建 RedisTemplate Bean，显式地指定了key和value的序列化方式为StringRedisSerializer，并且将其作为RedisTemplate的泛型参数，这样可以保证存储的数据类型是符合我们期望的。另外，显式地配置RedisTemplate Bean，也可以让我们更加灵活地配置连接工厂、连接池、超时时间等，以满足不同的业务需求。

opsForHash()方法操作示例

Redis 哈希表数据结构是一个 key-value 的无序散列表，适合于存储对象类型的数据。opsForHash() 方法提供了对 Redis 哈希表数据结构的操作方法。
优点：

• 可以对对象类型的数据进行存储和读取。
• 数据结构灵活，可以根据具体需求动态调整哈希表的大小。
• 支持原子性操作。

适用场景：

• 存储对象类型的数据。
• 数据量较大，需要进行分布式存储的场景。

// 存储哈希表数据
redisTemplate.opsForHash().put("myHash", "field1", "value1");
redisTemplate.opsForHash().put("myHash", "field2", "value2");

// 获取哈希表中指定字段的值
Object value1 = redisTemplate.opsForHash().get("myHash", "field1");

// 获取整个哈希表
Map<Object, Object> hash = redisTemplate.opsForHash().entries("myHash");

// 判断哈希表中是否存在指定字段
boolean exists = redisTemplate.opsForHash().hasKey("myHash", "field1");

// 删除哈希表中的字段
redisTemplate.opsForHash().delete("myHash", "field1");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

opsForValue()方法操作示例

Redis 字符串数据结构是一个简单的 key-value 结构，适合于存储简单的数据类型，如字符串、数字等。opsForValue() 方法提供了对 Redis 字符串数据结构的操作方法。
优点：

• 存储和读取速度快。
• 支持原子性操作。

适用场景：

• 存储简单的数据类型，如字符串、数字等。

// 存储字符串数据
redisTemplate.opsForValue().set("myKey", "myValue");

// 获取字符串数据
String value = (String) redisTemplate.opsForValue().get("myKey");

// 判断键是否存在
boolean exists = redisTemplate.opsForValue().exists("myKey");

// 删除键
redisTemplate.opsForValue().delete("myKey");

1
2
3
4
5
6
7
8
9
10
11
12

opsForCluster() 方法操作示例

Redis 集群是 Redis 分布式部署的一种方式，适合于数据量较大，需要进行分布式存储的场景。opsForCluster() 方法提供了对 Redis 集群的操作方法。
优点：

• 支持高可用性部署。
• 支持数据分片存储。

适用场景：

• 数据量较大，需要进行分布式存储的场景。

// 获取集群信息
List<RedisClusterNode> nodes = redisTemplate.opsForCluster().getClusterNodes();

// 获取集群节点数量
int nodeCount = redisTemplate.opsForCluster().clusterGetNodeCount();

1
2
3
4
5
6

opsForGeo() 方法操作示例

Redis 地理位置数据结构是一个字符串类型的有序集合，其中每个元素都有一个经纬度坐标，适合于存储地理位置信息。opsForGeo() 方法提供了对 Redis 地理位置数据结构的操作方法。

优点：

• 灵活、高效地处理地理位置信息。
• 支持多种查询方式。

适用场景：

• 存储和查询地理位置信息。

// 存储地理位置信息
redisTemplate.opsForGeo().add("myGeo", new Point(116.397128, 39.916527), "Beijing");
redisTemplate.opsForGeo().add("myGeo", new Point(113.964458, 22.547056), "Hong Kong");

// 获取指定位置的经纬度信息
Point point = redisTemplate.opsForGeo().position("myGeo", "Beijing");

// 获取两个位置之间的距离
Distance distance = redisTemplate.opsForGeo().distance("myGeo", "Beijing", "Hong Kong");

// 获取指定位置附近的地理位置信息
List<GeoResult<RedisGeoCommands.GeoLocation<String>>> locations = redisTemplate.opsForGeo().radius("myGeo", new Circle(new Point(116.397128, 39.916527), 100), GeoRadiusCommandArgs.newGeoRadiusArgs().sortDescending());

1
2
3
4
5
6
7
8
9
10
11
12
13

opsForList() 方法操作示例

Redis 列表数据结构是一个简单的链表结构，适合于存储有序的元素列表。opsForList() 方法提供了对 Redis 列表数据结构的操作方法。

优点：

• 可以快速地添加、删除元素。
• 支持原子性操作。

适用场景：

• 存储有序的元素列表。

// 在列表左侧插入元素
redisTemplate.opsForList().leftPush("myList", "value1");
redisTemplate.opsForList().leftPush("myList", "value2");

// 在列表右侧插入元素
redisTemplate.opsForList().rightPush("myList", "value3");
redisTemplate.opsForList().rightPush("myList", "value4");

// 获取列表指定范围的元素
List<Object> range = redisTemplate.opsForList().range("myList", 0, -1);

// 弹出列表左侧的元素
Object leftPopValue = redisTemplate.opsForList().leftPop("myList");

// 弹出列表右侧的元素
Object rightPopValue = redisTemplate.opsForList().rightPop("myList");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

opsForHyperLogLog() 方法操作示例

Redis HyperLogLog 数据结构是一种基数估计算法，用于统计唯一元素的数量。opsForHyperLogLog() 方法提供了对 Redis HyperLogLog 数据结构的操作方法。

优点：

• 可以在不占用大量内存的情况下，高效地统计唯一元素的数量。

适用场景：

• 统计唯一元素的数量。

// 添加元素到 HyperLogLog
redisTemplate.opsForHyperLogLog().add("myHyperLogLog", "element1");
redisTemplate.opsForHyperLogLog().add("myHyperLogLog", "element2");

// 获取 HyperLogLog 的基数
long cardinality = redisTemplate.opsForHyperLogLog().size("myHyperLogLog");

// 合并多个 HyperLogLog
redisTemplate.opsForHyperLogLog().union("destinationHyperLogLog", "myHyperLogLog1", "myHyperLogLog2");

1
2
3
4
5
6
7
8
9
10

opsForSet() 方法操作示例

Redis 集合数据结构是一个无序的字符串类型集合，适合于存储不重复的数据。opsForSet() 方法提供了对 Redis 集合数据结构的操作方法。

优点：

• 可以快速地添加、删除元素。
• 支持原子性操作。

适用场景：

• 存储不重复的数据。

// 添加元素到集合
redisTemplate.opsForSet().add("mySet", "element1");
redisTemplate.opsForSet().add("mySet", "element2");

// 获取集合中的所有元素
Set<Object> members = redisTemplate.opsForSet().members("mySet");

// 判断元素是否在集合中
boolean isMember = redisTemplate.opsForSet().isMember("mySet", "element1");

// 从集合中删除元素
redisTemplate.opsForSet().remove("mySet", "element1");

1
2
3
4
5
6
7
8
9
10
11
12
13

opsForStream() 方法操作示例

Redis Stream 数据结构是一个可持久化的日志结构，适合于高吞吐量的消息队列和事件处理。opsForStream() 方法提供了对 Redis Stream 数据结构的操作方法。

优点：

• 高效地处理消息队列和事件处理。
• 可以对数据进行持久化存储。

适用场景：

• 高吞吐量的消息队列和事件处理。

// 创建 Stream
ObjectRecord<String, String> record1 = StreamRecords.string("key1", "value1").withStreamKey("myStream");
ObjectRecord<String, String> record2 = StreamRecords.string("key2", "value2").withStreamKey("myStream");
redisTemplate.opsForStream().add(record1);
redisTemplate.opsForStream().add(record2);

// 读取 Stream
StreamOffset<String> streamOffset = StreamOffset.create("myStream", ReadOffset.from("0"));
List<MapRecord<String, String, String>> messages = redisTemplate.opsForStream().read(streamOffset);

// 删除 Stream
redisTemplate.opsForStream().delete("myStream");

1
2
3
4
5
6
7
8
9
10
11
12
13

opsForZSet() 方法操作示例

Redis 有序集合数据结构是一个有序的字符串类型集合，适合于存储需要排序的数据。opsForZSet() 方法提供了对 Redis 有序集合数据结构的操作方法。

优点：

• 可以快速地添加、删除元素。
• 可以对数据进行排序。

适用场景：

• 存储需要排序的数据。

// 添加元素到有序集合
redisTemplate.opsForZSet().add("myZSet", "element1", 1.0);
redisTemplate.opsForZSet().add("myZSet", "element2", 2.0);

// 获取有序集合中指定范围的元素
Set<Object> range = redisTemplate.opsForZSet().range("myZSet", 0, -1);

// 获取有序集合中指定元素的分数
Double score = redisTemplate.opsForZSet().score("myZSet", "element1");

// 移除有序集合中的元素
redisTemplate.opsForZSet().remove("myZSet", "element1");

1
2
3
4
5
6
7
8
9
10
11
12
13