首页 > 数据库 > Redis > Redis五种基本类型和业务场景和使用

Redis的五种基本类型和业务场景和使用方式

2024-10-17 16:41:43 作者：小疙瘩的编程之路

Redis是一种高性能的键值存储数据库,支持多种数据结构如字符串、列表、集合、哈希表和有序集合等,它提供丰富的API和持久化功能,适用于缓存、消息队列、排行榜等多种场景,Redis能够实现高速读写操作,尤其适合需要快速响应的应用

Redis是什么？

Redis是非关系性数据库，Redis 是一个开源的高性能键值数据库，主要用于数据存储和缓存。

它支持多种数据结构，如字符串、哈希、列表、集合和有序集合等。

Redis的特点

‌丰富的数据类型‌：Redis不仅支持字符串类型的键值对，还支持列表、哈希、集合和有序集合等多种数据结构，这使得Redis能够处理更复杂的数据操作‌23。
‌高性能‌：由于数据存储在内存中，Redis能够提供极高的读写速度，适用于需要高速响应的场景‌12。
‌持久化功能‌：Redis支持将内存中的数据周期性地写入磁盘，确保数据的安全性，同时也支持将修改操作写入追加的记录文件，实现主从同步‌14。
‌可扩展性‌：Redis提供了丰富的API和脚本功能，支持通过Lua脚本批量执行命令，同时也支持水平扩展，类似于分库分表

依赖

<!--  SpringBoot Boot Redis  -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>
<!-- Spring Boot Starter Test -->
<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-test</artifactId>
     <scope>test</scope>
  </dependency>
<!-- JUnit 5 -->
<dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-api</artifactId>
      <version>5.8.2</version>
      <scope>test</scope>
</dependency>
<dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-engine</artifactId>
      <version>5.8.2</version>
      <scope>test</scope>
</dependency>

配置

spring:
  redis:
    host: 你的ip
    port: 6379

redis的配置类（用于格式转换，处理乱码）

package com.bwie.common.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
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.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new
                Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);

        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();

        return template;
    }
}

String（字符串）

特点

最基本的数据类型，可以包含任何类型的数据，比如整数、浮点数或者字符串。
最大存储容量为 512MB。

业务场景

缓存: 存储临时数据，如用户会话信息或页面缓存。
计数器: 可以用来实现访问计数器、点赞数等自增功能。
配置存储: 存储应用程序的配置参数。

代码使用案例

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

import static org.junit.jupiter.api.Assertions.assertEquals;

@SpringBootTest
public class StringExampleTest {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Test
    public void testString() {
        // 设置字符串值
        redisTemplate.opsForValue().set("myStringKey", "Hello Redis!");

        // 获取并验证字符串值
        String value = (String) redisTemplate.opsForValue().get("myStringKey");
        assertEquals("Hello Redis!", value);  // 验证值是否正确

        // 更新字符串值
        redisTemplate.opsForValue().set("myStringKey", "Updated Value");
        assertEquals("Updated Value", redisTemplate.opsForValue().get("myStringKey"));  // 验证更新后的值

        // 增加计数器值
        redisTemplate.opsForValue().increment("myCounter", 1);
        assertEquals(1, redisTemplate.opsForValue().get("myCounter"));  // 验证计数器值

        // 设置带有过期时间的字符串
        redisTemplate.opsForValue().set("tempKey", "I will expire soon", 10);
        // 验证过期时间是否小于10秒（实际过期时间可能略小于10秒）
        assertEquals(true, redisTemplate.getExpire("tempKey") < 10L);
    }
}

注意：

如果说注入的时候泛型和配置类不一样的话，可能会导致使用不了配置类的相关配置，就会采用redisTemplate原有的配置，然后存储到的redis的数据就是一些乱码。
一定要保证注入的泛型和配置类一样，这样存储到redis中的数据格式就是正确的

List（列表）

特点

是一个链表结构，可以包含多个字符串值（元素）。
可以在列表的两端进行插入（Push）和删除（Pop）操作，支持对列表进行修剪（Trim）以保留指定范围的元素。

业务场景

消息队列：通过列表实现生产者/消费者模式。
时间线：存储用户的活动日志或社交媒体的时间线。
任务调度：存储待处理任务的队列。

代码使用案例

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

import java.util.List;

import static org.junit.jupiter.api.Assertions.assertEquals;

@SpringBootTest
public class ListExampleTest {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Test
    public void testList() {
        // 向列表中添加元素
        redisTemplate.opsForList().leftPush("myListKey", "item1");
        redisTemplate.opsForList().leftPush("myListKey", "item2");

        // 获取并验证列表中的所有元素
        List<Object> list = redisTemplate.opsForList().range("myListKey", 0, -1);
        assertEquals(true, list.contains("item2"));  // 验证列表包含 item2
        assertEquals(true, list.contains("item1"));  // 验证列表包含 item1

        // 从列表中弹出元素
        Object poppedItem = redisTemplate.opsForList().rightPop("myListKey");
        assertEquals("item1", poppedItem);  // 验证弹出的元素是 item1

        // 获取列表长度
        Long size = redisTemplate.opsForList().size("myListKey");
        assertEquals(1L, size);  // 验证列表长度为 1

        // 在列表开头插入新元素
        redisTemplate.opsForList().insert("myListKey", 0, "item0");
        List<Object> updatedList = redisTemplate.opsForList().range("myListKey", 0, -1);
        assertEquals(true, updatedList.contains("item0"));  // 验证列表包含 item0
        assertEquals(true, updatedList.contains("item2"));  // 验证列表仍包含 item2
    }
}

注意：

如果说注入的时候泛型和配置类不一样的话，可能会导致使用不了配置类的相关配置，就会采用redisTemplate原有的配置，然后存储到的redis的数据就是一些乱码。
一定要保证注入的泛型和配置类一样，这样存储到redis中的数据格式就是正确的

Set（集合）

特点

是字符串的无序集合，集合中的元素都是独一无二的，即不允许重复。
支持集合间的交集、并集、差集等操作，可以用于处理多个用户的共同好友、标签等数据。

业务场景

标签系统：存储用户的兴趣标签或文章的标签。
好友关系：存储用户的好友列表，快速查找共同好友。
去重：用于去重操作，例如统计独立访客数。

代码使用案例

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

import java.util.Set;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;

@SpringBootTest
public class SetExampleTest {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Test
    public void testSet() {
        // 向集合中添加元素
        redisTemplate.opsForSet().add("mySetKey", "member1", "member2", "member3");

        // 获取并验证集合中的所有成员
        Set<Object> members = redisTemplate.opsForSet().members("mySetKey");
        assertEquals(true, members.contains("member1"));  // 验证集合包含 member1
        assertEquals(true, members.contains("member2"));  // 验证集合包含 member2
        assertEquals(true, members.contains("member3"));  // 验证集合包含 member3

        // 从集合中删除某个成员
        redisTemplate.opsForSet().remove("mySetKey", "member2");
        assertFalse(redisTemplate.opsForSet().members("mySetKey").contains("member2"));  // 验证 member2 已被删除

        // 检查某个成员是否在集合中
        Boolean isMember = redisTemplate.opsForSet().isMember("mySetKey", "member1");
        assertEquals(true, isMember);  // 验证 member1 仍在集合中
    }
}

注意：

如果说注入的时候泛型和配置类不一样的话，可能会导致使用不了配置类的相关配置，就会采用redisTemplate原有的配置，然后存储到的redis的数据就是一些乱码。
一定要保证注入的泛型和配置类一样，这样存储到redis中的数据格式就是正确的

Hash（哈希表）

特点

是一个键值对集合，适合用于存储对象。
每个 Hash 可以存储多达 2^32 - 1 键值对（40多亿）。
适合存储和读取整个对象，如用户信息、商品信息等。

业务场景

用户信息: 存储用户的基本信息，例如用户名、邮箱和其他属性。
商品属性: 存储商品的详细信息，如价格、描述、库存等。
状态信息: 用于存储状态信息，比如会话或任务的当前状态。

代码使用案例

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

import java.util.HashMap;
import java.util.Map;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;

@SpringBootTest
public class HashExampleTest {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Test
    public void testHash() {
        // 创建 HashMap 并存储到 Redis 中
        Map<String, Object> myHash = new HashMap<>();
        myHash.put("field1", "value1");
        myHash.put("field2", "value2");
        redisTemplate.opsForHash().putAll("myHashKey", myHash);

        // 获取并验证哈希字段值
        String fieldValue = (String) redisTemplate.opsForHash().get("myHashKey", "field1");
        assertEquals("value1", fieldValue);  // 验证字段值

        // 更新哈希字段
        redisTemplate.opsForHash().put("myHashKey", "field1", "newValue");
        assertEquals("newValue", redisTemplate.opsForHash().get("myHashKey", "field1"));  // 验证更新后的值

        // 删除哈希字段
        redisTemplate.opsForHash().delete("myHashKey", "field2");
        assertFalse(redisTemplate.opsForHash().hasKey("myHashKey", "field2"));  // 验证字段是否已删除

        // 获取所有字段及其值
        Map<Object, Object> entries = redisTemplate.opsForHash().entries("myHashKey");
        assertEquals(true, entries.containsKey("field1"));  // 验证字段存在
        assertEquals("newValue", entries.get("field1"));  // 验证字段值
    }
}

注意：

如果说注入的时候泛型和配置类不一样的话，可能会导致使用不了配置类的相关配置，就会采用redisTemplate原有的配置，然后存储到的redis的数据就是一些乱码。
一定要保证注入的泛型和配置类一样，这样存储到redis中的数据格式就是正确的

Sorted Set（有序集合）

特点

类似于集合，每个成员都是唯一的，但每个成员都会关联一个浮点数值，称为分数（score）。
成员按分数排序，可以根据分数范围获取成员，也可以按分数获取排名。
适合需要根据分数进行排序和范围查询的场景，如排行榜、时间线等

业务场景

排行榜: 存储用户积分、排名等，可以快速查询前 N 名用户。
时间戳排序: 根据时间戳的排序存储事件日志。
优先级队列: 实现任务调度，按照优先级处理任务。

代码使用案例

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

import java.util.Set;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;

@SpringBootTest
public class ZSetExampleTest {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Test
    public void testZSet() {
        // 向有序集合中添加元素
        redisTemplate.opsForZSet().add("myZSetKey", "member1", 1);
        redisTemplate.opsForZSet().add("myZSetKey", "member2", 2);

        // 获取并验证有序集合中的所有成员
        Set<Object> zSetMembers = redisTemplate.opsForZSet().range("myZSetKey", 0, -1);
        assertEquals(true, zSetMembers.contains("member1"));  // 验证 member1 存在
        assertEquals(true, zSetMembers.contains("member2"));  // 验证 member2 存在

        // 更新元素的分数
        redisTemplate.opsForZSet().incrementScore("myZSetKey", "member1", 3);
        Double score = redisTemplate.opsForZSet().score("myZSetKey", "member1");
        assertEquals(4.0, score);  // 验证 member1 的分数更新为 4.0

        // 获取指定分数范围内的成员
        Set<Object> rangeByScore = redisTemplate.opsForZSet().rangeByScore("myZSetKey", 1, 2);
        assertEquals(true, rangeByScore.contains("member2"));  // 验证 member2 在分数范围内

        // 从有序集合中删除某个成员
        redisTemplate.opsForZSet().remove("myZSetKey", "member2");
        assertFalse(redisTemplate.opsForZSet().range("myZSetKey", 0, -1).contains("member2"));  // 验证 member2 已被删除
    }
}

注意：

如果说注入的时候泛型和配置类不一样的话，可能会导致使用不了配置类的相关配置，就会采用redisTemplate原有的配置，然后存储到的redis的数据就是一些乱码。
一定要保证注入的泛型和配置类一样，这样存储到redis中的数据格式就是正确的

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。

Redis的五种基本类型和业务场景和使用方式

Redis是什么？

Redis的特点

依赖

配置

redis的配置类（用于格式转换，处理乱码）

String（字符串）

特点

业务场景

代码使用案例

List（列表）

特点

业务场景

代码使用案例

Set（集合）

特点

业务场景

代码使用案例

Hash（哈希表）

特点

业务场景

代码使用案例

Sorted Set（有序集合）

特点

业务场景

代码使用案例

总结

您可能感兴趣的文章: