devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Redis是什么？怎么使用？

作者：IT小白 | 2024-06-10 06:33:35

赞

踩

redis是什么

1.什么是Redis？

        Redis（Remote Dictionary Server）是一个开源的内存数据存储系统，通过使用键值对的方式进行数据存储。它支持多种数据结构，包括字符串（string）、哈希（hash）、列表（list）、集合（set）、有序集合（sorted set）等。

Redis 的主要特点包括：

  1. 内存存储：Redis 将所有数据存储在内存中，这使得它非常快速和高效。同时，Redis 也支持将数据持久化到磁盘，以保证数据的持久性。
  2. 高性能：Redis 是单线程的，通过使用异步的方式处理网络请求，使得 Redis 能够处理高并发的情况。
  3. 多数据结构支持：Redis 提供了多种丰富的数据结构，可以满足不同场景下的数据存储需求。
  4. 支持事务：Redis 提供了简单的事务支持，可以通过 MULTI、EXEC、DISCARD 和 WATCH 等命令实现事务操作。
  5. 发布/订阅：Redis 支持发布/订阅模式，可以实现消息的发布和订阅，用于构建实时的消息系统。
  6. 高可用性：Redis 提供了主从复制和哨兵机制，以实现数据的高可用性和故障转移。

2.怎么安装？

    Linux系统

  1. 在 Redis 官方网站上下载最新的 Redis 软件包：http://redis.io/download 。

  2. 解压下载的 Redis 软件包。使用以下命令解压：

    $ tar xvzf redis-x.x.x.tar.gz

    其中 “x.x.x” 是 Redis 的版本号。

  3. 进入解压后的 Redis 目录：

    $ cd redis-x.x.x

  4. 在 Redis 目录中，执行以下命令编译 Redis：

    $ make

    这将编译 Redis 的可执行文件。

  5. 安装 Redis。执行以下命令：

    $ make install

    这将把 Redis 的可执行文件和相关的配置文件放置到系统默认的目录中。

  6. 配置 Redis。在 Redis 目录中，复制 redis.conf 配置文件到指定位置：

    $ cp redis.conf /etc/redis.conf

    可以根据需要修改 redis.conf 文件中的配置选项，比如设置密码、修改监听端口等。

  7. 启动 Redis。执行以下命令：

    $ redis-server /etc/redis.conf

    这会启动 Redis 服务器进程，然后就可以使用redis了。

Windows系统

  1. 访问 Redis 官方网站：https://redis.io/download 。

  2. 在页面上选择 Stable 版本并下载最新的 Redis for Windows 版本。

  3. 解压下载的 Redis 软件包。你可以选择一个目录，比如 C:\Redis ，将解压后的文件放在该目录下。

  4. 进入 Redis 目录，在其中找到 redis.windows.conf 文件并将其重命名为 redis.conf 。

  5. 编辑 redis.conf 文件。你可以根据需要修改一些默认配置，比如设置密码、修改监听端口等。一般情况下，你可以保留默认配置。

  6. 打开一个命令提示符（CMD）窗口，并导航到 Redis 目录下。

  7. 启动 Redis 服务器。在命令提示符窗口中运行以下命令：

    redis-server.exe redis.conf

    这将启动 Redis 服务器。

  8. 打开另一个命令提示符（CMD）窗口，并导航到 Redis 目录下。

  9. 启动 Redis 客户端。在命令提示符窗口中运行以下命令：

    redis-cli.exe

    这将启动 Redis 客户端，并连接到本地运行的 Redis 服务器。

现在你已经成功在 Windows 上安装和启动了 Redis。你可以使用 Redis 客户端执行各种 Redis 命令来管理和操作 Redis 数据库。

3.Redis的常用数据类型

  • 字符串（String）

    • 特点：存储一个字符串值。可以是任意类型的数据，不限于文本。是redis中最常用的数据类型
    • 代码示例：

      • 添加字符串、查询、追加、获取长度、判断是否存在：

        1. # 添加字符串键值对
        2. SET key value
        3.  
        4. # 查询字符串值
        5. GET key
        6.  
        7. # 追加字符串值
        8. APPEND key value
        9.  
        10. # 获取字符串的长度
        11. STRLEN key
        12.  
        13. # 判断键是否存在
        14. EXISTS key

        使用 SET 命令可以给指定的键设置字符串值。使用 GET 命令可以获取字符串键的值。APPEND 命令用于追加字符串值到指定键的值末尾。STRLEN 命令用于获取字符串键的长度。EXISTS 命令可以判断键是否存在。

      • 自增、自减操作：

        1. # 对键的值进行自增
        2. INCR key
        3.  
        4. # 对键的值进行自减
        5. DECR key

        使用 INCR 命令可以将键的值递增 1，若键不存在则创建并设置值为 1。使用 DECR 命令则将键的值递减 1。

      • 截取、替换字符串操作：

        1. # 截取字符串的一部分
        2. GETRANGE key start end
        3.  
        4. # 替换字符串的一部分
        5. SETRANGE key offset value

        使用 GETRANGE 命令可以将字符串的一部分截取出来。使用 SETRANGE 命令可以在指定偏移量处替换字符串的一部分。

      • 设置过期时间、不存在设置操作：

        1. # 设置键的过期时间（以秒为单位）
        2. EXPIRE key seconds
        3.  
        4. # 仅当键不存在时，设置键的值
        5. SETNX key value

        使用 EXPIRE 命令可以设置键的过期时间，单位为秒。使用 SETNX 命令可以在键不存在时设置键的值，若键已存在，则不进行任何操作。

      • MSET、MGET 操作：

        1. # 设置多个键值对
        2. MSET key1 value1 key2 value2 ...
        3.  
        4. # 获取多个键的值
        5. MGET key1 key2 ...

        使用 MSET 命令可以设置多个键值对。使用 MGET 命令可以获取多个键的值。

      • 添加、获取对象、GETSET 操作：

        1. # 将对象转换成 JSON 字符串，并存储到键中
        2. SET key JSON_string
        3.  
        4. # 获取键中存储的 JSON 字符串，并将其转换回对象
        5. GET key
        6.  
        7. # 设置键的新值，并返回旧值
        8. GETSET key new_value

        可以使用 SET 命令将对象转换为 JSON 字符串，并存储到键中。使用 GET 命令可以获取键中存储的 JSON 字符串，并将其转换回对象。GETSET 命令可以设置键的新值，并返回

  • 哈希（Hash）

    • 特点：存储字段和对应的值的映射关系。比String更适合存储对象。
    • 代码示例：

      • 添加哈希、查询、查询所有、删除指定值、获取哈希长度、判断key是否存在：

        1. # 添加哈希字段和值
        2. HSET key field1 value1
        3.  
        4. # 查询哈希字段的值
        5. HGET key field
        6.  
        7. # 查询哈希中所有字段和值
        8. HGETALL key
        9.  
        10. # 删除哈希中的指定字段
        11. HDEL key field
        12.  
        13. # 获取哈希的长度（即字段的数量）
        14. HLEN key
        15.  
        16. # 判断指定字段是否存在于哈希中
        17. HEXISTS key field

        使用 HSET 命令可以给哈希中的字段设置对应的值。使用 HGET 命令可以查询哈希中某个字段的值。使用 HGETALL 命令可以查询哈希中所有字段和对应的值。HDEL 命令可以删除哈希中的指定字段。HLEN 命令用于获取哈希的长度（即字段的数量）。HEXISTS 命令可以判断指定字段是否存在于哈希中。

      • 获取所有键、获取所有值、给值加增量、存在不添加：

        1. # 获取哈希中的所有字段
        2. HKEYS key
        3.  
        4. # 获取哈希中的所有值
        5. HVALS key
        6.  
        7. # 给哈希字段的值增加指定增量
        8. HINCRBY key field increment
        9.  
        10. # 仅当哈希字段不存在时，设置哈希字段的值
        11. HSETNX key field value

        使用 HKEYS 命令可以获取哈希中的所有字段（即键）。HVALS 命令用于获取哈希中的所有值。HINCRBY 命令可以给哈希字段的值增加指定的增量。HSETNX 命令仅当哈希字段不存在时设置字段的值，如果字段已存在，则不进行任何操作。

  • 列表（List）

    • 特点：存储有序的字符串元素列表。
      • 实际上是一个链表，before Node after ， left，right 都可以插入值
      • 如果key 不存在，创建新的链表
      • 如果key存在，新增内容
      • 如果移除了所有值，空链表，也代表不存在！
      • 在两边插入或者改动值，效率最高！ 中间元素，相对来说效率会低一点~
      • 消息排队！消息队列 （Lpush Rpop）， 栈（ Lpush Lpop）！
    • 代码示例：

      • 创建新链表或新增内容：

        1. # 在链表左侧插入值
        2. LPUSH key value
        3.  
        4. # 在链表右侧插入值
        5. RPUSH key value

        如果 key 不存在，会自动创建一个新的链表，并将值插入其中。如果 key 已经存在，则将新的值插入链表的左侧或右侧。

      • 移除值：

        1. # 从链表左侧移除并返回一个值
        2. LPOP key
        3.  
        4. # 从链表右侧移除并返回一个值
        5. RPOP key

        这些命令会从链表的左侧或右侧移除一个值，并将其返回。

      • 检查链表是否为空：

        1. # 获取链表的长度
        2. LLEN key

        使用 LLEN 命令可以获取链表中元素的个数。如果返回的结果为 0，则表示链表为空，也可以理解为该 key 不存在。

      • 消息队列是 Redis 中链表的常见应用场景之一，可以使用 LPUSH 和 RPOP 命令来实现排队和出队操作。以下是一个示例：

        1. # 排队，将消息添加到队列的左侧
        2. LPUSH message_queue "message1"
        3. LPUSH message_queue "message2"
        4. LPUSH message_queue "message3"
        5.  
        6. # 出队，从队列的右侧获取消息
        7. RPOP message_queue

        这样，每次调用 RPOP 命令都可以获取到最新加入队列的消息，实现了简单的消息队列功能。类似地，如果使用 LPUSH 和 LPOP 命令，则可以将链表用作堆栈数据结构，实现先入后出的行为。

        需要注意的是，由于 Redis 使用内存存储数据，链表的长度不宜过长。当链表长度较长时，中间插入或修改元素的效率确实会相对较低，因此需要根据具体应用场景合理选择数据结构和操作方式。

  • 集合（Set）

    • 特点：存储无序且唯一的字符串元素集合。可实现共同好友、共同关注等需求。
    • 代码示例：

      • 添加元素、查看所有元素、判断元素是否存在、查看集合长度、移除指定元素：

        1. # 添加元素到集合
        2. SADD key element1 element2 element3
        3.  
        4. # 查看集合中的所有元素
        5. SMEMBERS key
        6.  
        7. # 判断元素是否存在于集合中
        8. SISMEMBER key element
        9.  
        10. # 查看集合的长度
        11. SCARD key
        12.  
        13. # 移除集合中指定的元素
        14. SREM key element

        使用 SADD 命令可以向集合中添加一个或多个元素，而 SMEMBERS 命令用于获取集合中的所有元素。SISMEMBER 命令可以判断某个元素是否存在于集合中，返回布尔值。SCARD 命令用于获取集合的长度（即集合中元素的数量）。SREM 命令可以从集合中移除指定的元素。

      • 抽取随机元素：

        1. # 从集合中随机返回指定数量的元素
        2. SRANDMEMBER key [count]

        使用 SRANDMEMBER 命令可以随机从集合中返回指定数量的元素，默认情况下返回一个元素。该命令不会删除集合中的元素。

      • 随机删除元素、移动指定元素到新集合：

        1. # 随机从集合中删除一个或多个元素，并返回被删除的元素
        2. SPOP key [count]
        3.  
        4. # 将指定元素从一个集合移动到另一个集合
        5. SMOVE source_key destination_key element

        SPOP 命令可以随机从集合中删除一个或多个元素，并返回被删除的元素。SMOVE 命令可以将指定的元素从一个集合移动到另一个集合。

      • 差集、交集、并集操作：

        1. # 计算多个集合的差集
        2. SDIFF key1 key2 ...
        3.  
        4. # 计算多个集合的交集
        5. SINTER key1 key2 ...
        6.  
        7. # 计算多个集合的并集
        8. SUNION key1 key2 ...

        使用 SDIFF命令可以计算多个集合的差集，即在第一个集合中但不在其他集合中的元素。SINTER 命令可以计算多个集合的交集，即同时存在于所有集合中的元素。SUNION 命令可以计算多个集合的并集，即包含所有集合中的元素。

  • 有序集合（Sorted Set）

    • 特点：存储有序的字符串元素集合，每个元素关联一个分数用于排序。成绩表排序，工资表排序，年龄排序等需求可以用zset来实现。
    • 代码示例：

      • 添加元素、查询、排序查询、查询所有值包含 key：

        1. # 添加有序集合的元素
        2. ZADD key score1 member1 score2 member2 ...
        3.  
        4. # 查询有序集合指定排名范围内的元素
        5. ZRANGE key start stop
        6.  
        7. # 按分数范围排序，查询有序集合的元素
        8. ZRANGEBYSCORE key min max
        9.  
        10. # 按分数范围排序，查询有序集合的元素（按降序）
        11. ZREVRANGE key start stop
        12.  
        13. # 按分数范围排序，查询有序集合的元素，并返回每个元素的分数
        14. ZRANGEBYSCORE key min max WITHSCORES

        使用 ZADD 命令可以向有序集合添加一个或多个元素，每个元素都有一个数值（分数）来进行排序。使用 ZRANGE 命令可以按照指定的排名范围查询有序集合的元素。ZRANGEBYSCORE 命令则按分数范围对有序集合进行排序，并查询符合条件的元素。ZREVRANGE 命令用于按分数范围对有序集合进行排序，并按降序查询元素。ZRANGEBYSCORE 命令的 WITHSCORES 选项可以返回每个元素的分数。

      • 移除元素、查看元素个数、查询指定区间内的元素个数：

        1. # 从有序集合中移除指定的元素
        2. ZREM key member1 member2 ...
        3.  
        4. # 获取有序集合的元素个数
        5. ZCARD key
        6.  
        7. # 获取指定分数范围内的元素个数
        8. ZCOUNT key min max

        使用 ZREM 命令可以从有序集合中移除指定的元素。ZCARD 命令用于获取有序集合中元素的个数。ZCOUNT 命令可以查询有序集合中指定分数范围内的元素个数。

这些只是 Redis 支持的一部分数据类型和常用命令的示例，你可以根据具体需求选择合适的数据类型，并参考 Redis 官方文档或相关教程获取更多详细信息。

4.Redis事务

     

当涉及到 Redis 事务时，以下是一些常用的 Redis 命令和一个基本的事务示例：

  • MULTI：标记事务的开始，将客户端设置为事务模式。
  • EXEC：执行事务中的所有命令，并将结果返回给客户端。
  • WATCH key1 key2 …：监视给定的键，如果在事务执行期间有其他客户端对这些键进行了修改，事务将被中止。
  • UNWATCH：取消对所有键的监视。
  • DISCARD：放弃执行事务中的所有命令，将客户端从事务模式中恢复。
  • SET key value：将给定的键设置为相应的值。
  • GET key：获取给定键的值。
  • DEL key1 key2 …：删除给定的键及其关联的值。
  • INCR key：将给定键的值增加 1。
  • DECR key：将给定键的值减少 1。
  • HSET key field value：给指定键的哈希表中的字段设置值。
  • HGETALL key：获取指定键的哈希表中的所有字段和值。
  • 以下是一个简单的 Redis 事务示例，展示了如何将多个命令封装在一个事务中： 
    1. MULTI
    2. SET key1 value1
    3. SET key2 value2
    4. GET key1
    5. GET key2
    6. EXEC

在这个示例中，首先使用 MULTI 命令标记事务的开始。然后，使用 SET 命令设置键 key1 和 key2 的值。接下来，使用 GET 命令获取 key1 和 key2 的值。最后，通过 EXEC 命令执行事务中的所有命令，并返回执行结果。

5.开发流程

      编程式缓存

             1.创建springboot项目，导入redis依赖

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

             2.添加配置文件

  1. #指定 Redis 服务器的主机地址，这里设置为 localhost 表示 Redis 服务器在本地。
  2. spring.redis.host=localhost  
  3.  
  4. #指定 Redis 服务器的端口号，默认为 6379。
  5. spring.redis.port=6379
  6.  
  7. #指定要连接的 Redis 数据库索引，默认为 0。Redis 支持多个数据库，索引从 0 开始。
  8. spring.redis.database=0
  9.  
  10. #指定连接池中的最大活跃连接数。当连接池中的连接数达到此值时，后续请求会被阻塞，直到有连接被释放。
  11. spring.redis.jedis.pool.max-active=100
  12.  
  13. #指定获取连接的最大等待时间。当连接池中的连接已经被用完，且达到了最大活跃连接数时，后续请求会等待一定时间，超过这个时间后会抛出异常。
  14. spring.redis.jedis.pool.max-wait=100ms
  15.  
  16. #指定连接池中的最大空闲连接数。当连接池中的空闲连接数超过此值时，多余的连接会被释放。
  17. spring.redis.jedis.pool.max-idle=100
  18.  
  19. #指定连接池中的最小空闲连接数。当连接池中的空闲连接数低于此值时，连接池会创建新的连接
  20. spring.redis.jedis.pool.min-idle=10

            3.编写配置类

  1. package com.blb.day06.config;
  2.  
  3. import com.fasterxml.jackson.annotation.JsonAutoDetect;
  4. import com.fasterxml.jackson.annotation.PropertyAccessor;
  5. import com.fasterxml.jackson.databind.ObjectMapper;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.context.annotation.Configuration;
  8. import org.springframework.data.redis.connection.RedisConnectionFactory;
  9. import org.springframework.data.redis.core.RedisTemplate;
  10. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  11. import org.springframework.data.redis.serializer.StringRedisSerializer;
  12.  
  13. @Configuration
  14. public class RedisConfig {
  15.  
  16.     @Bean
  17.     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
  18.         RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
  19.         template.setConnectionFactory(factory);
  20.         // 配置序列化器
  21.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
  22.         ObjectMapper om = new ObjectMapper();
  23.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  24.         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  25.         jackson2JsonRedisSerializer.setObjectMapper(om);
  26.         StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
  27.         // key采用String的序列化方式
  28.         template.setKeySerializer(stringRedisSerializer);
  29.         // hash的key也采用String的序列化方式
  30.         template.setHashKeySerializer(stringRedisSerializer);
  31.         // value序列化方式采用jackson
  32.         template.setValueSerializer(jackson2JsonRedisSerializer);
  33.         // hash的value序列化方式采用jackson序列化器
  34.         template.setHashValueSerializer(jackson2JsonRedisSerializer);
  35.         template.afterPropertiesSet();
  36.         return template;
  37.     }
  38. }

              4.使用配置类方法

  1.  public Article getArticle(Long id) {
  2.         ValueOperations<String, Object> article = redisTemplate.opsForValue();
  3.         Article atc = (Article) article.get(Article + id);
  4.  
  5.         if (atc!=null){
  6.             System.out.println("返回redis缓存"+atc);
  7.             return atc;
  8.         }
  9.  
  10.         Article selectById = articleMapper.selectById(id);
  11.  
  12.         if (selectById!=null){
  13.             System.out.println("MySQL查到了，返回"+selectById);
  14.             article.set(Article+id,selectById);
  15.             return selectById;
  16.         }
  17.         System.out.println("MySQL没查到，无数据，返回null");
  18.         return null;
  19.     }

        声明式缓存

        编程式缓存使用复杂，代码侵入性高，推荐使用声明式缓存，通过注解来实现热点数据缓存

  1. 在启动类上添加EnableCaching注解 
    1. //启动缓存
    2. @EnableCaching
  2. 配置类         
    1. @Configuration
    2. public class RedisConfig {
    3.  
    4.     @Bean
    5.     public RedisCacheConfiguration provideRedisCacheConfiguration(){
    6.         //加载默认配置
    7.         RedisCacheConfiguration conf = RedisCacheConfiguration.defaultCacheConfig();
    8.         //返回Jackson序列化器
    9.         return conf.serializeValuesWith(
    10.                 RedisSerializationContext.SerializationPair
    11.                 .fromSerializer(new GenericJackson2JsonRedisSerializer()));
    12.     }
    13. }

  3. 常用声明式缓存注解

  • @Cacheable：声明方法的返回值应该被缓存，并且缓存的结果会被存储到缓存中。常用的属性包括：
  • 示例：
    1. @Cacheable(value = "products", key = "#id")
    2. public Product getProductById(Long id) {
    3.    // ...
    4. }
  • value 或 cacheNames：指定缓存的名称或缓存组。
  • key：指定缓存的键，用于获取和存储缓存结果。可以使用 SpEL 表达式指定键的生成规则。
  • condition：指定一个 SpEL 表达式，在满足表达式条件时才进行缓存。
  • unless：指定一个 SpEL 表达式，当表达式条件为真时，不进行缓存。

  • @CachePut：声明方法将结果存储到缓存中，无论缓存是否已存在。常用的属性与 @Cacheable 相似。

    示例：

    1. @CachePut(value = "products", key = "#product.id")
    2. public void saveProduct(Product product) {
    3.    // ...
    4. }

  • @CacheEvict：声明方法应该从缓存中移除一个或多个缓存项。

    示例：

    1. @CacheEvict(value = "products", key = "#id")
    2. public void deleteProduct(Long id) {
    3.    // ...
    4. }
    • value 或 cacheNames：指定要清除缓存的名称或缓存组。
    • key：指定要清除缓存的键，用于匹配具体的缓存项。
    • allEntries：设置为 true，表示清除所有缓存项。
    • beforeInvocation：设置为 true，表示在方法调用之前执行缓存清除操作。

  • @Caching：将多个缓存注解应用到同一个方法上，以实现复杂的缓存行为。

    示例：

    1. @Caching(
    2.     cacheable = {
    3.         @Cacheable(value = "products", key = "#id"),
    4.         @Cacheable(value = "products", key = "'name:' + #name")
    5.     },
    6.     evict = {
    7.         @CacheEvict(value = "products", key = "'all'")
    8.     }
    9. )
    10. public Product getProduct(Long id, String name) {
    11.    // ...
    12. }

上述注解只是 Spring Cache 中的一部分，还有其他一些注解可供使用，如 @CacheConfig 用于配置缓存的默认属性，@CacheResolver 用于自定义缓存解析器等。

请注意，具体的注解使用和属性配置可能会受到缓存框架的支持和版本的限制，建议查阅相应的文档来了解详细的用法和配置说明。

总结

        总的来说，Redis简单易用，高性能，广泛应用于缓存、队列、计数器、实时更新等场景，成为了互联网领域的重要组件之一。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/697544
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号