Redis 学习笔记

目录

引言

[什么是 Redis](#什么是 Redis)

[Redis 的主要特点](#Redis 的主要特点)

[Redis 的应用场景](#Redis 的应用场景)

[Redis 下载与安装](#Redis 下载与安装)

[Redis 入门](#Redis 入门)

[启动 redis 服务](#启动 redis 服务)

[连接 redis 服务](#连接 redis 服务)

[连接其它 redis 服务](#连接其它 redis 服务)

[Redis 客户端界面](#Redis 客户端界面)

[Redis 常用的 5 中数据类型](#Redis 常用的 5 中数据类型)

各种数据类型的特点

字符串（String）常用操作命令

哈希操作命令

列表操作命令

集合操作命令

有序集合操作命令

[Redis 通用命令](#Redis 通用命令)

[在 Java 中操作 Redis](#在 Java 中操作 Redis)

[Rdis 的 Java 客户端](#Rdis 的 Java 客户端)

[Spring Data Redis 使用方式](#Spring Data Redis 使用方式)

[1、导入Maven 的pom坐标](#1、导入Maven 的pom坐标)

[2、配置文件 yaml](#2、配置文件 yaml)

[3、编写config配置类，创建 RedisTemplate对象](#3、编写config配置类，创建 RedisTemplate对象)

[4、通过 注入 RedisTemplate 对象操作 Redis](#4、通过 注入 RedisTemplate 对象操作 Redis)

Java对Redis字符串操作

[Java对 Redis 哈希操作](#Java对 Redis 哈希操作)

[Java对 Redis 的 列表操作](#Java对 Redis 的 列表操作)

[Java对 Redis 的集合操作](#Java对 Redis 的集合操作)

[Java对 Redis 的有序集合操作](#Java对 Redis 的有序集合操作)

[Java 对 Redis 的通用命令操作](#Java 对 Redis 的通用命令操作)

---

引言

Redis（Remote Dictionary Server）是一个开源的高性能键值存储数据库，以其卓越的性能和低延迟特性而闻名。它支持多种类型的数据结构，如字符串、哈希、列表、集合、有序集合等，使其成为开发人员在构建各种应用程序时的首选。

官网: https://redis.io

中文网: https://www.redis.net.cn/

什么是 Redis

Redis 是一个基于内存的数据库，它提供了原子操作、丰富的数据类型、持久化选项以及一个简单的发布/订阅系统。由于其数据存储在内存中，Redis 能够提供极高的读写速度，使其成为处理大量数据时的理想选择。

Redis 的主要特点

1. 性能：Redis 的读写速度非常快，因为它的数据存储在内存中。
2. 持久化：尽管 Redis 是基于内存的，但它提供了多种持久化选项，确保数据的安全性。
3. 数据结构：Redis 支持多种数据结构，如字符串、列表、集合、有序集合、散列等。
4. 原子性：Redis 的所有操作都是原子性的，这意味着它们要么完全执行，要么完全不执行。
5. 复制：Redis 支持主从复制，可以用于数据冗余和负载均衡。
6. 高可用性：通过哨兵系统，Redis 可以实现高可用性配置，自动处理主服务器故障转移。
7. Lua 脚本：Redis 支持 Lua 脚本，允许在服务器端执行复杂的操作。
8. 发布/订阅：Redis 提供了一个发布/订阅系统，允许客户端订阅消息频道并接收消息。

Redis 的应用场景

1. 缓存：由于其高速性能，Redis 常被用作数据库查询结果的缓存。
2. 会话存储：在 Web 应用中，Redis 可以用来存储用户会话。
3. 排行榜：Redis 的有序集合非常适合实现排行榜功能。
4. 消息队列：Redis 可以用作消息队列系统，处理异步任务。
5. 实时分析：Redis 可以用于实时分析，如计数器、实时分析等。

Redis 下载与安装

Redis安装包分为 Windows 版和 Linux 版:

Windows版下载地址 : https://github.com/microsoftarchive/redis/releases

Linux版下载地址 : https://download.redis.io/releases/

Redis的 Windows 版属于绿色软件、直接解压即可使用，解压后目录结构如下：

Redis 入门

启动 redis 服务

redis-server.exe redis.windows.conf

连接 redis 服务

redis-cli.exe

连接其它 redis 服务

redis-cli.exe -h localhost -p 6379 -a 123456

• -h ： host ，表示连接的服务地址
• -p：port，表示连接的服务端口
• -a：password，表示连接服务的登录密码

Redis 客户端界面

由于命令行窗口的客户端不太方便，所以这里常用的客户端软件如下，自行从网络下载。

Redis 常用的 5 中数据类型

Redis 存储的是 key-value 结构的数据，其中 key 是字符串类型，value 有 5 种常用的数据类型:

• 字符串 string
• 哈希 hash
• 列表 list
• 集合 set
• 有序集合 sorted set / zset

各种数据类型的特点

• 字符串（String）：普通字符串，Redis 中最简单的数据类型
• 哈希（hash）：也叫散列，类似于 Java 中的 HashMap 结构
• 列表（list）：按照插入顺序排序，可以有重复元素，类似于 Java中的 LinkedList
• 集合（set）：无序集合，没有重复元素，类似于 Java 中的 HashSet
• 有序集合（sorted set / zset）：集合中每个元素关联一个分数（score），根据分数升序排序，没有重复元素。

字符串（String）常用操作命令

• SET key value：设置指定 key 的值
• GET key：获取指定 key 的值
• SETEX key seconds value：设置指定 key 的值，并将 key 的过期时间设为 seconds 秒
• SETNX key value：只有在 key 不存在时 设置 key 的值

哈希操作命令

• HSET key field value ： 将哈希表 key 中的字段 field 的值设为 value
• HGET key field ： 获取存储在哈希表中指定字段的值
• HDEL key field ： 删除存储在哈希表中的指定字段
• HKEYS key ：获取哈希表中所有字段
• HVALUES key：获取哈希表中所有值

列表操作命令

• LPUSH key value1 [value2] ：将一个或多个值插入到列表头部
• LRANGE key start stop ：获取列表指定范围内的元素
• RPOP key ： 移除并获取列表最后一个元素
• LLEN key ：获取列表长度

集合操作命令

• SADD key member1 [member2] ：想集合添加一个或多个成员
• SMEMBERS key ：返回集合中的所有成员
• SCARD key ：获取集合的成员数
• SINTER key1 [key2] ：返回给定所有集合的交集
• SUNION key1 [key2] ：返回所有给定集合的并集
• SREM key member1 [member2] ：删除集合中一个或多个成员

有序集合操作命令

• ZADD key score1 member1 [score2 member2] ：向有序集合添加一个或多个成员
• ZRANGE key start stop [WITHSCORES] ：通过索引区间返回有序集合中指定区间内的成员
• ZINCRBY key increment member ：有序集合中对指定成员的分数加上增量 increment
• ZREM key member [member ...] ：移除有序集合中的一个或多个成员

Redis 通用命令

Redis的通用命令是不分数据类型的，都可以使用的命令:

• KEYS pattern ：查找所有符合给定模式( pattern) 的 key
• EXISTS key ：检查给定 key 是否存在
• TYPE key ：返回 key 所存储的值的类型
• DEL key ： 该命令用于在 key 存在时删除 key

在 Java 中操作 Redis

Rdis 的 Java 客户端

Redis 的 Java 客户端很多，常用的几种:

• Jedis
• Lettuce
• Spring Data Redis

Spring Data Redis 是Spring 的一部分，对 Redis 底层开发包进行了高度封装,在 spring项目中，可以使用spring Data Redis来简化操作。

Spring Data Redis 使用方式

1、导入Maven 的pom坐标

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

2、配置文件 yaml

  redis:
    host: localhost
    port: 6379
    password: 123456
    database: 0

3、编写config配置类，创建 RedisTemplate对象

import lombok.extern.slf4j.Slf4j;
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;

@Slf4j
@Configuration
public class RedisConfiguration {

    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory){
        log.info("开始创建 redis 模板对象");
        RedisTemplate redisTemplate = new RedisTemplate<>();
//        设置 Redis 的连接工厂对象
        redisTemplate.setConnectionFactory(redisConnectionFactory);
//        设置 Redis key 的序列化器
        redisTemplate.setKeySerializer(new StringRedisSerializer());
//        设置 Redis value 的序列化器
//      redisTemplate.setValueSerializer(new StringRedisSerializer());
        return redisTemplate;
    }
}

4、通过 注入 RedisTemplate 对象操作 Redis

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

import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@SpringBootTest
public class SpingDataRedisTest {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void testRedisTemplate(){
        System.out.println(redisTemplate);

//        操作字符串类型 的 数据
        ValueOperations valueOperations = redisTemplate.opsForValue();

//        操作哈希表 的 数据
        HashOperations hashOperations = redisTemplate.opsForHash();

//        操作 列表 的 数据
        ListOperations listOperations = redisTemplate.opsForList();

//        操作 集合 的数据
        SetOperations setOperations = redisTemplate.opsForSet();

//        操作 有序集合 的数据
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();
    }
}

Java对Redis字符串操作

    /**
     * 操作字符串类型 的 数据
     */
    @Test
    public void testString(){

        //        操作字符串类型 的 数据
        ValueOperations valueOperations = redisTemplate.opsForValue();

        // 设置 数据   set
        valueOperations.set("name", "angindem");

        // 根据 key 获取 字符串数值      get
        String name = (String) valueOperations.get("name");

        System.out.println("name = " + name);

//        设置 时间限制的 字符串数据 3 min      setex
        valueOperations.set("code", "1234",3, TimeUnit.MINUTES);

//       设置 不存在时执行，当存在时不执行      setnx
        valueOperations.setIfAbsent("lock","1");
        valueOperations.setIfAbsent("lock","2");
    }

Java对 Redis 哈希操作

    @Test
    public void testHash(){
        //        操作哈希表 的 数据
        HashOperations hashOperations = redisTemplate.opsForHash();

        //      根据 key  设置 哈希表 并赋值      hset
        hashOperations.put("100", "name","tom" );
        hashOperations.put("100", "age","20" );

//        获取 key 中的  hashKey 的值         hget
        String name = (String)hashOperations.get("100", "name");

        System.out.println("name = " + name);

//        获取 key 中的 所有 hashKey      hkeys
        Set keys = hashOperations.keys("100");
        System.out.println(keys);

        //        获取 key 中的 所有 value        hvals
        List values = hashOperations.values("100");
        values.forEach(System.out::println);

//        根据 key 删除 对应的  hashkey 的 键对值          hdel
        hashOperations.delete("100","age");
    }

Java对 Redis 的 列表操作

    @Test
    public void testList(){
        //        操作 列表 的 数据
        ListOperations listOperations = redisTemplate.opsForList();

//        根据 key 插入 列表头 多个数值   lpush
        listOperations.leftPushAll("mylist", "a","b","c");
//        根据 key 插入 列表头 单个数值   lpush
        listOperations.leftPush("mylist", "d");

//        根据 key  获取 列表所有数值  lrange
        List mylist = listOperations.range("mylist", 0, -1);
        System.out.println(mylist);

//        根据 key 右弹出 数值    rpop
        listOperations.rightPop("mylist");

//        根据 key 获取 列表大小
        Long size = listOperations.size("mylist");
        System.out.println("listSize = " + size);
    }

Java对 Redis 的集合操作

    @Test
    public void testSet(){
//        操作 集合 的数据
        SetOperations setOperations = redisTemplate.opsForSet();

//        根据 key 添加 集合数据  sadd
        setOperations.add("set1", "a","b","c","d");
        setOperations.add("set2", "a","b","x","y");

//        根据 key 获取 全部集合数据   smembers
        Set set1Members = setOperations.members("set1");
        System.out.println(set1Members);

//        根据 key 获取 集合大小   scard
        Long set1Size = setOperations.size("set1");
        System.out.println(set1Size);

//        根据 key1 和 key2 获取集合的  交集  sinter
        Set intersect = setOperations.intersect("set1", "set2");
        System.out.println(intersect);

//        根据 key1 和 key2 获取集合的  并集  sunion
        Set union = setOperations.union("set1", "set2");
        System.out.println(union);

//        根据 key 删除集合数据    srem
        setOperations.remove("set1", "a","b");
    }

Java对 Redis 的有序集合操作

    @Test
    public void testZset(){
        //        操作 有序集合 的数据
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();

//        根据 key 添加 有序集合数据  zadd
        zSetOperations.add("zset1", "a",10);
        zSetOperations.add("zset1", "b",12);
        zSetOperations.add("zset1", "c",9);

//        根据 key 获取 有序集合数据 zrange
        Set zset1 = zSetOperations.range("zset1", 0, -1);
        System.out.println(zset1);

//        根据 key 对 有序集合的 value 添加 分数    zincrby
        zSetOperations.incrementScore("zset1", "c", 10);

//        根据 key 删除 有序集合数据      zrem
        zSetOperations.remove("zset1", "a","b");
    }

Java 对 Redis 的通用命令操作

    @Test
    public void testCommon(){

        // 获取所有 redis 中的 key    keys
        Set keys = redisTemplate.keys("*");
        System.out.println(keys);

//        判断 Redis 中的 key 是否存在 exists
        Boolean name = redisTemplate.hasKey("name");
        Boolean set1 = redisTemplate.hasKey("set1");
        System.out.println("nameIsExists? = " + name);
        System.out.println("set1IsExists? = " + set1);

//        根据 key  获取 key 的类型        type
        for (Object key : keys){
            DataType type = redisTemplate.type(key);
            System.out.println(type.name());
        }
//         根据 key 删除对应的 key数据   del
        redisTemplate.delete("mylist");
    }