初识Redis

最新推荐文章于 2025-06-11 12:45:49 发布
最新推荐文章于 2025-06-11 12:45:49 发布
阅读量65 收藏
点赞数
分类专栏： java基础知识 文章标签： redis java 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_51675791/article/details/128793493
版权

1. 简介

  • Redis（Remote Dictionary Server )，即远程字典服务 !
    官网：redis中文文档
    是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。

  • Redis能干嘛？

  • （解决速度不匹配问题，因为关系数据库的数据存在磁盘，磁盘和cpu的速度差距太大，故引入了高速缓存，将部分数据存在内存，就像cache系统和虚拟存储系统）
    1、内存存储、持久化，内存中是断电即失、所以说持久化很重要（rdb、aof） 2、效率高，可以用于高速缓存
    3、发布订阅系统
    4、地图信息分析
    5、计时器、计数器（浏览量！）

2.常用命令

ping  #查看当前连接是否正常，正常返回PONG

clear  #清楚当前控制台（为了更好的看到下面输入的命令）

keys *  #查看当前库里所有的key

FLUSHALL  #清空所有库的内容

set name dingdada  #添加一个key为‘name’ value为‘dingdada’的数据

get name  #查询key为‘name’的value值

EXISTS name  #判断当前key是否存在

move name 1  #移除当前库1的key为‘name‘的数据

EXPIRE name 15  #设置key为’name‘的数据过期时间为15秒 单位seconds

ttl name  #查看当前key为’name‘的剩余生命周期时间
 
 ttl name  #如若返回-2，证明key已过期

（见官方文档）

3.五大数据类型

String List Set Hash zSet

4.SpringBoot整合redis

（1）配置pom.xml文件

 <!--集成redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>2.1.7.RELEASE</version>
        </dependency>

（2）配置yml文件

server:
  port: 10001

spring:
  redis:
    host: 127.0.0.1
    port: 6379

（3）测试连接

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;

@SpringBootTest
public class testRedis {

    @Autowired(required = false)
    private RedisTemplate redisTemplate;

    @Test
    void getName(){
        redisTemplate.opsForValue().set("name","dadadingdada!");
        System.out.println(redisTemplate.opsForValue().get("name"));
    }
}

5.封装RedisUtils类

在实际工作中，我们不可能用RedisTemplate 来操作Redis的，因为实在太繁琐，所以我们一般自定义一个RedisUtils工具类来操作Redis！

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Component
public final class RedisUtil {

    @Resource
    private RedisTemplate<String, Object> redisTemplate;


    public Set<String> keys(String keys){
        try {
            return redisTemplate.keys(keys);
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 指定缓存失效时间
     * @param key 键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
     * 根据key 获取过期时间
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }
    /**
     * 判断key是否存在
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
     * 删除缓存
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
            }
        }
    }
    /**
     * 普通缓存获取
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }
    /**
     * 普通缓存放入
     * @param key 键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
     /**
     * 普通缓存放入, 不存在放入，存在返回
     * @param key 键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean setnx(String key, Object value) {
        try {
            redisTemplate.opsForValue().setIfAbsent(key,value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
     * 普通缓存放入并设置时间
     * @param key 键
     * @param value 值
     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

  /**
     * 普通缓存放入并设置时间,不存在放入，存在返回
     * @param key 键
     * @param value 值
     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean setnx(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().setIfAbsent(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 递增
     * @param key 键
     * @param delta 要增加几(大于0)
     * @return
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }
    /**
     * 递减
     * @param key 键
     * @param delta 要减少几(小于0)
     * @return
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }
    /**
     * HashGet
     * @param key 键 不能为null
     * @param item 项 不能为null
     * @return 值
     */
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }
    /**
     * 获取hashKey对应的所有键值
     * @param key 键
     * @return 对应的多个键值
     */
    public Map<Object, Object> hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }
    /**
     * HashSet
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    public boolean hmset(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
     * HashSet 并设置时间
     * @param key 键
     * @param map 对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public boolean hmset(String key, Map<String, Object> map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key 键
     * @param item 项
     * @param value 值
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key 键
     * @param item 项
     * @param value 值
     * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
     * 删除hash表中的值
     * @param key 键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }
    /**
     * 判断hash表中是否有该项的值
     * @param key 键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }
    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     * @param key 键
     * @param item 项
     * @param by 要增加几(大于0)
     * @return
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }
    /**
     * hash递减
     * @param key 键
     * @param item 项
     * @param by 要减少记(小于0)
     * @return
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }
    /**
     * 根据key获取Set中的所有值
     * @param key 键
     * @return
     */
    public Set<Object> sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    /**
     * 根据value从一个set中查询,是否存在
     * @param key 键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
     * 将数据放入set缓存
     * @param key 键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    /**
     * 将set数据放入缓存
     * @param key 键
     * @param time 时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSetAndTime(String key, long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0){
                expire(key, time);
            }
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    /**
     * 获取set缓存的长度
     * @param key 键
     * @return
     */
    public long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    /**
     * 移除值为value的
     * @param key 键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    public long setRemove(String key, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    // ===============================list=================================
    /**
     * 获取list缓存的内容
     * @param key 键
     * @param start 开始
     * @param end 结束 0 到 -1代表所有值
     * @return
     */
    public List<Object> lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    /**
     * 获取list缓存的长度
     * @param key 键
     * @return
     */
    public long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    /**
     * 通过索引 获取list中的值
     * @param key 键
     * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     * @return
     */
    public Object lGetIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     * @return
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0){
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
     * 将list放入缓存
     *
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0){
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
     * 根据索引修改list中的某条数据
     * @param key 键
     * @param index 索引
     * @param value 值
     * @return
     */
    public boolean lUpdateIndex(String key, long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
     * 移除N个值为value
     * @param key 键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
    public long lRemove(String key, long count, Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
}
初识redis
weixin_44697116的博客
05-27 872
初识redis redis 是一款高性能的NOSQL类型的非关系型数据库 NOSQL 和关系型数据库比较 优点: 1)成本: nosql数据库简单易部署,基本都是开源软件,不需要像使用oracle那样花费大量成本购买使用，相比关系型数据库价格便宜。 2)查询速度: nosql数据库将数据存储于缓存之中，关系型数据库将数据存储在硬盘中，自然查询速度远不及nosql数据库。 3)存储数据的格式: nosql的存储格式是key ,value形式、文档形式、图片形式等等，所以可以存储基础类型以及对象或者是集合等各种
头歌初识redis答案.rar
06-07
在头歌平台初识Redis的答案可以总结如下： 一、基础知识 Redis数据库数量： Redis默认有16个数据库，可以使用select命令进行切换。 数据库大小与键的查看： 使用DBSIZE命令查看当前数据库的大小（即键的数量）。 ...
头歌解答 初识Redis
Rozen_a的博客
11-10 1817
按照不同排序规则取出排序在参数提供的区间范围内的文章。start：从排序为 start 的文章开始获取。设置有序列表，键为 educoder-zset。启动 Redis 客户端 redis-cli。添加键：python，值为：language。添加键: redis，值为：database。设置列表，键为 educoder-list。设置哈希，键为 educoder-hash。使用方法2创建客户端r1连接到 Redis。设置集合，键为 educoder-set。添加键：ruby，值为：language。
初识 Redis
无耻的鱼
04-19 851
cmd 链接 lunix ssh root@127.0.0.1 pwd> 密码 ** redis ** 字符串 设置 set name = wuzhi set age = 16 递加 incr age #17 incrby 递加指定 整数 递减 decr age #16 decrby 递加指定 整数 追加字符串 append age 12 #1612 删除 del age #...
头歌 初识Redis
m0_51919640的博客
11-25 5574
头歌 初识Redis
头歌初识redis答案
youyouxiong的博客
06-06 696
Redis支持五大基本数据类型，包括String（字符串）、List（链表）、Set（集合）、Zset（Sorted Set，有序集合）和Hash（哈希类型）。Redis支持多种命令，如DBSIZE（查看db大小）、keys *（查看所有key）、flushdb（清除当前数据库）、FLUSHALL（清除所有数据库）等。List类型：支持lpush（将一个值插入到列表头部）、rpush（将一个值插入到列表尾部）、lpop（移除并获取列表的第一个元素）等操作。以上就是对头歌初识Redis答案的归纳和总结。
Redis第一章之初识Redis
醒狮运维:热爱IT运维的老攻城狮们
03-09 825
揭秘Redis之第一章初识Redis 理论篇 1.redis是什么？ ​ Redis 是一种基于键值对（key-value）的NoSQL数据库，与很多键值对数据库不同的是，Redis中的值可以是由string（字符串）、hash（哈希）、list（列表）、set（集合）、zset（有序集合）、Bitmaps（位图）、HyperLogLog、GEO（地理信息定位）等多种数据结构和算法组成，因此Redis可以满足很多的应用场景，而且因为Redis会将所有数据都存放在内存中，所以它的读写性能非常惊人。 ​ R
第9章 初识Redis Cluster.rar
04-25
一站式学习Redis 从入门...包含Redis基础，使用经验介绍、Java，Python客户端示范、Redis使用规范，由浅入深讲解并伴有企业中Redis开发的相关项目以及大规模Redis的实战经验，是开发和运维人员系统学习Redis的必备内容
【Redis】持久化
Sakura_ding的博客
06-08 886
Redis 提供了两种持久化方案：RDB 和 AOF。RDB 视为内存的快照，产生的内容更加紧凑，占用空间较小，恢复时速度更快。但产生 RDB 的开销较大，不适合进行实时持久化，一般用于冷备和主从复制。AOF 视为对修改命令保存，在恢复时需要重放命令。并且有重写机制来定期压缩 AOF 文件。RDB 和 AOF 都使用 fork 创建子进程，利用 Linux 子进程拥有父进程内存快照的特点进行持久化，尽可能不影响主进程继续处理后续命令。
Java八股文——Redis篇
郎逸的博客
06-04 2011
本文详细介绍了Redis的一些常见问题，并总结了Java面试中常见的有关Redis的面试题，供大家参考。
Redis Key过期策略
随遇而安
06-07 1094
持久化方式生成时处理加载时处理复制传播RDB过滤过期Key二次检查全量同步AOF记录DEL命令按序重放增量同步混合模式RDB部分过滤组合加载混合同步。
Redis 安装配置和性能优化
2503_91100205的博客
06-05 1163
Redis 作为高性能内存键值存储系统，在现代互联网架构中扮演着核心角色。本文将从基础概念入手，详细介绍 Redis 的安装部署、核心配置、常用命令、持久化机制及性能优化策略，帮助读者全面掌握 Redis 技术栈。内存存储带来的极致性能（十万级 QPS）丰富的数据结构（String/List/Hash/Set/ZSet）完善的持久化与高可用方案（RDB/AOF/主从/集群）简单易用的命令体系与客户端支持。
Redis的过期策略和淘汰策略
从不水文，坚持创作，加油
06-10 1137
Redis数据管理策略深度解析 本文详细探讨了Redis的过期策略和淘汰策略，通过超市商品管理的生动比喻，解析了Redis如何高效管理数据生命周期。文章分为三部分：首先介绍定时删除、惰性删除和定期删除三种过期策略及其适用场景；然后分析8种淘汰策略，重点对比LRU和LFU算法差异；最后提供实战配置指南，结合电商平台、新闻应用等案例，分享优化经验。作者建议根据业务特点选择合适的策略组合，通过监控关键指标持续优化，可提升Redis性能30%-50%。文章强调合理配置过期和淘汰策略对系统性能的重要性，为开发者提供了
Redis免费客户端工具推荐
最新发布
lanwp5302的博客
06-11 272
Redis 有多个免费的客户端工具，适用于不同的操作系统和用途。
使用docker在3台服务器上搭建基于redis 6.x的一主两从三台均是哨兵模式
langmeng110的博客
06-10 1030
本文详细介绍了在CentOS7.6系统上使用Docker部署Redis6.0.8哨兵模式的完整流程。首先说明了环境要求和服务器的版本配置，然后分析了哨兵模式的优缺点及适用场景。接着以1主2从架构为基础，通过配置sentinel.conf文件、编写启动脚本、分别在主从节点上启动哨兵服务等步骤，逐步搭建了高可用的Redis哨兵集群。最后通过模拟主节点故障、验证自动故障转移功能，确认哨兵模式搭建成功。文章提供了完整的配置文件模板和操作命令，适合需要实现Redis高可用的运维人员参考。
若依使用RedisCache需要注意的事项
weixin_51480428的博客
06-10 297
Redis存储对象时会自动添加@type字段记录类路径名，当存取双方的类路径不一致时会导致类型转换错误。临时解决方案是手动移除JSON中的@type信息后再转换。永久解决方案是通过配置RedisTemplate，使用FastJson2JsonRedisSerializer并设置ParserConfig，开启自动类型支持并指定允许的包名前缀，从而确保序列化和反序列化时类型匹配。这解决了因类路径不同导致的对象转换问题。
基于深度强化学习的Scrapy-Redis分布式爬虫动态调度策略研究
2506_92055592的博客
06-06 1304
六、我们提出了一种基于深度强化学习的Scrapy-Redis分布式爬虫动态调度策略，通过将深度强化学习技术与现有的分布式爬虫框架相结合，有效解决了传统调度策略的局限性。未来的研究可以进一步探索更高效的深度强化学习算法，结合迁移学习等技术，提高策略的泛化能力和适应性，推动分布式爬虫技术的发展与应用。在Scrapy-Redis分布式爬虫系统中，多个爬虫节点可以从Redis队列中获取待抓取的URL任务，完成抓取后将新的URL和数据进行相应处理并放回Redis，实现任务的循环执行。完成普通任务给予较低奖励。
头哥初识Redis
05-22
### Redis 入门教程初学者指南 Redis 是一种高性能的键值对存储系统，广泛应用于缓存、消息队列以及实时数据分析等领域。作为一种开源软件，Redis 支持多种数据结构操作并提供丰富的功能特性。 #### 1. Redis 的基本概念 Redis 不仅是一个简单的键值存储工具，还提供了字符串(String)、哈希(Hash)、列表(List)、集合(Set) 和有序集合(Sorted Set)等多种复杂的数据结构支持[^2]。这些数据结构使得开发者能够轻松实现各种复杂的业务逻辑需求。 #### 2. 安装与环境配置 为了开始使用 Redis，需要先完成其安装过程。通常情况下，在 Linux 或 macOS 平台上可以通过包管理器快速部署；而在 Windows 上则推荐采用 Docker 方式来运行容器化的 Redis 实例[^3]。 ```bash # 使用 apt-get (适用于 Ubuntu/Debian 系统) sudo apt update && sudo apt install redis-server # 启动服务 redis-server --daemonize yes ``` #### 3. 数据结构解析 以下是几种主要的数据类型及其用途简介： - **字符串（String）**: 存储单个值或者作为计数器使用。 ```lua SET mykey "Hello" GET mykey INCR counter_key ``` - **哈希（Hash）**: 表示对象字段与其对应值得映射关系。 ```lua HMSET user:1000 username "Alice" age 30 HGETALL user:1000 ``` - **列表（List）**: 双端链表形式用于 FIFO/LIFO 队列模拟。 ```lua LPUSH queue item1 RPUSH queue item2 LPOP queue RPOP queue ``` - **集合（Set）& 有序集合（Sorted Set）**: 去重后的无序集合或带分数权重排序版。 ```lua SADD unique_items apple banana orange SMEMBERS unique_items ZADD leaderboard 95 alice 87 bob 76 charlie ZRANGE leaderboard 0 -1 WITHSCORES ``` #### 4. 持久化机制 Redis 提供两种持久化方式——RDB 快照文件和 AOF 日志记录。前者定期保存当前状态至磁盘，后者则是每次写命令追加到日志中以便恢复时重新执行所有变更[^2]^。 #### 5. 应用场景举例 一些常见的 Redis 使用场景包括但不限于网站访问统计、会话管理、购物车暂存等功能模块开发过程中发挥重要作用. --- ###
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值