开发者

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

开发者 https://www.devze.com 2024-10-22 09:09 出处：网络 作者： 小疙瘩的编程之路
目录Redis是什么？Redis的特点依赖配置redis的配置类（用于格式转换，处理乱码）String（字符串）特点业务场景代码使用案例List（列表）特点业务场景代码使用案例Set（集合）特点业务场景代码使用案例Hash（哈希表）
相关专题：Redis业务场景Redis业务场景使用Redis五种基本类型
目录
  • Redis是什么？
  • Redis的特点
  • 依赖
  • 配置
  • redis的配置类（用于格式转换，处理乱码）
  • String（字符串）
    • 特点
    • 业务场景
    • 代码使用案例
  • List（列表）
    • 特点
    • 业务场景
    • 代码使用案例
  • Set（集合）
    • 特点
    • 业务场景
    • 代码使用案例
  • Hash（哈希表）
    • 特点
    • 业务场景
    • 代码使用案例
  • Sorted Set（有序集合）
    • 特点
    • 业务场景
    • 代码使用案例
  • 总结

    Redis是什么？

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

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

    Redis的特点

    1. ‌丰富的数据类型‌：Redis不仅支持字符串类型的键值对，还支持列表、哈希、集合和有序集合等多种数据结构，这使得Redis能够处理更复杂的数据操作‌23。
    2. ‌高性能‌：由于数据存储在内存中，Redis能够提供极高的读写速度，适用于需要高速响应的场景‌12。
    3. ‌持久化功能‌：Redis支持将内存中的数据周期性地写入磁盘，确保数据的安全性，同时也支持将修改操作写入追加的记录文件，实现主从同步‌14。
    4. ‌可扩展性‌：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.getEWDAGzFxpire("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",WDAGzF "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中的数据格式就是正确的

    总结

    以上为个人经验，希望能给大家一个参考，也希望大家多多支持编程客栈(www.devze.com)。

    0

    上一篇:

    :下一篇

    更多 数据库 相关资讯：

    精彩评论

    暂无评论...
    登录 注册
    Qedev.com
    验证码 换一张
    取 消

    关注公众号

    热门标签

    图文推荐

    MySQL字符串日期格式转换的几种常用方法例子解析

    MySQL字符串日期格式转换的几种常用方法例子解析
    详解Sqlsugar调用Oracle的存储过程

    详解Sqlsugar调用Oracle的存储过程
    SpringBoot集成Mongodb的操作方法

    SpringBoot集成Mongodb的操作方法
    如何用PyMongo在Python中操作MongoDB的超完整指南

    如何用PyMongo在Python中操作MongoDB的超完整指南
    Vcenter清理/storage/archive空间的处理方式

    Vcenter清理/storage/archive空间的处理方式
    mysql插入带emoji表情的数据报错问题

    mysql插入带emoji表情的数据报错问题
    Mysql允许他人访问本机数据库的实现步骤

    Mysql允许他人访问本机数据库的实现步骤
    Docker安装MongoDB的过程(mongo.latest)

    Docker安装MongoDB的过程(mongo.latest)

    开发者开发者网给大家分享系统运维,大数据运维,云计算,编程开发技巧,路由交换,运维和开发相关的资讯及技术文章，同时StackOverflow中文社区，知识经验交流分享。

    法律声明：本站内容均为网友上传，网站举办方负责审核和监督，如存在版权或非法内容，欢迎举报，我们将尽快予以删除。邮箱：devze@qq.com

    Copyright © 2018-2020 开发者. All rights reserved. Powered by 开发者ICP备案号: 京ICP备10032868号-9