黑马基础Redis

01 初识Redis

1.1 认识NoSQL

	SQL	NoSQL
数据结构	结构化(Structured):设计之初，就有明确的结构	非结构化：无明确结构，键值对
数据关联	关联的(Relational):表和表之间可以通过外键，进行关联	无关联，表和表之间无约束力
查询	SQL查询	非SQL Redis get user:1, MongoDB db.users.find({_id: 1}), elasticsearch GET http://localhost:9200/users/1
事务	ACID	BASE
存储方式	磁盘	内存
扩展性	垂直	水平
使用场景	1)数据结构固定 2)相关业务对数据安全性，一致性要求较高	1)数据结构不固定 2)对一致性，安全性要求不高 3)对性能要求

1.2 认识Redis

Redis诞生于2009年全称是Remote Dictionary Server,远程词典服务器，是一个基于内存的键值型NoSQL数据库。

特征

• 键值(key-value)型，value支持多种不同数据结构，功能丰富
• 单线程，每个命令具备原子性
• 低延迟，速度快（基于内存，IO多路复用，良好的编码）。
• 支持数据持久化
• 支持主从集群，分片集群

1.3 安装Redis

部分过程省略。

redis.conf文件的一些配置

# 监听的地址，默认是127.0.0.1,会导致只能在本地访问，改为0.0.0.0则可以在任意IP访问，生产环境不要设置为0.0.0.0
bind 0.0.0.0
# 守护进程，修改为yes后即可后台运行
daemonize yes
# 密码，设置后访问Redis必须输入密码
requirepass 123321

Redis其它常见配置：

# 监听的端口
port 6379
# 工作目录，默认是当前目录，也就是redis-server时的命令，日志，持久化等文件会保存在这个目录
dir .
# 数据库数量，设置为1,代表只是用1个库，默认有16个库，编号0-15
databases 1
# 设置redis能使用最大内存
maxxmemory 512mb
# 日志文件，默认为空，不记录日志，可以指定日志文件名
logfile "redis.log"

启动Redis

redis-server redis.conf # 需要提前配置环境变量，才能在任意位置使用redis-server

停止服务

# 利用redis-cli来执行shutdown命令，即可停止Redis服务
# 因为之前配置了密码，因此需要通过 -u 来指定密码
redis-cli -u 123321 shutdown

1.3.1 开机自启

可以通过配置来实现开机自启。

新建一个系统服务文件：

vi /etc/systemd/system/redis.service

内容如下：

[Unit]
Description=redis-server
After=network.target

[Service]
Type=forking
ExecStart=/usr/local/redis/redis-6.2.5/bin/redis-server /usr/local/redis/redis-6.2.5/bin/redis.conf
PrivateTmp=true

[Install]
WantedBy=multi-user.target

然后重载系统服务：

systemctl daemon-reload

启动Redis

systemctl start redis

查看Redis状态

systemctl status redis

设置开机自启

systemctl enable redis

1.3.2 Redis客户端

1.3.2.1 Redis命令行客户端

redis-cli [options] [commonds]
其中常见的options有：

• -h 127.0.0.1:指定要连接的redis节点的IP地址，默认是127.0.0.1
• -p 6379:指定要连接的redis节点的端口，默认是6379
• a 123321:指定redis的访问密码
  其中commonds就是Redis的操作命令，例如：
• ping: 与redis服务端做心跳测试，服务端正常会返回pong

另外一种登录方式
redis-cli -h 127.0.0.1 -p 6379
可以建立连接，是同AUTH登录

AUTH 123321

1.3.2.2 RedisDesktop

收费

02 Redis常见命令

2.1 Redis数据结构介绍

Redis是一个key-value的数据库，key一般是String类型，不过value的类型多种多样：

key	value
String	hello world
Hash	{name:"Jack", age:21}
List	[A -> B -> C -> C]
Set	{A, B, C}
SortedSet	{A:1, B:2, C:3}
GEO	{A:{120.3，30.5}
BitMap	01010000110110
HyperLog	01101111100101

Redis为了方便学习，将操作不同数据类型的命令也做了分组，在官网(https://redis.io/commands)可以查看到不同的命令。

2.2 Redis通用命令

通用命令是对所有的数据类型都可以使用的命令。

• KEYS：查看符合模板的所有key,不建议在生产设备上使用。
• DEL：删除一个指定的key
• EXISTS：判断key是否存在
• EXPIRE：给一个key设置有效期，有效期到期时该key会被自动删除
• TTL：查看一个KEY的剩余有效期
  通过help [command]可以查看一个命令的具体用法。

2.3 String类型

String类型，也就是字符串类型，是Redis中最简单的存储类型。
其value是字符串，不过根据字符串的格式不同，又可以分为3类：

• string：普通字符串
• int：整数类型，可以做自增，自减操作
• float：浮点类型，可以做自增，自减操作
  不管哪种格式，底层都是字节数组形式存储，只不过是编码方式不同。字符串类型空间最大不能超过512m.

key	value
msg	hello world
num	10
score	92.5

String类型的常见命令

• SET：添加或者修改已经存在的一个String类型的键值对
• GET：根据key获取String类型的value
• MSET：批量添加多个String类型的键值对
• MGET：根据多个key获取多个String类型的value
• INCR：让一个整形的key自增1
• INCRBY：让一个整形的key自增并指定步长，例如:incrby num 2 让num自增2
• INCRBYFLOAT：让一个浮点数类型的数字自增长
• SETNX：添加一个String类型的键值对，前提是这个key不存在，否则不执行
• SETEX：添加一个String类型的键值对，并且指定有效期

key的结构

Redis的key允许有多个单词形成层架结构，多个单词之间用':'隔开，格式如下

项目名:业务名:类型:id

例如我们的项目名称叫heima，有user和product两种不同类型的数据，我们可以定义key:

• user相关的key：heima:user:1
• product相关的key：heima:product:1

如果Value是一个Java对象，例如一个User对象，则可以将对象序列化为JSON字符串后存储：

key	value
heima:user:1	{"id":1, "name":"Jack", "age":21}
heima:product:1	{"id":1, "name":"小米11", "price":4999}

2.4 Hash类型

Hash类型，也叫散列，其value是一个无序字典，类似于Java中的HashMap结构。
String结构是将对象序列化为JSON字符串后存储，当需要修改某个字段时很不方便。

key	value
heima:user:1	{name:"Jack",age:21}
heima:user:2	{name:"Rose",age:18}

Hash结构可以将对象中的每个字段独立存储，可以针对单个字段做CRUD:

• HSET key field value: 添加或者修改hash类型key的field值
• HGET key field: 获取一个hash类型key的field的值
• HMSET：批量添加多个hash类型key的field的值
• HMGET：批量获取多个hash类型key的field的值
• HGETALL：获取一个hash类型的key中所有的field和value
• HKEYS：获取一个hash类型的key中所有的field
• HVALS: 获取一个hash类型的key中所有value
• HINCRBY：让一个hash类型key的字段值自增并指定步长
• HSETNX：添加一个hash类型的key的field值，前提时这个field不存在，否则不执行。

2.5 List类型

Redis中的List类型与Java中的LinkedList类似，可以看做是一个双向链表结构。技持支正向检索和也支持反向检索。

特征也与LinkedList类似：

• 有序
• 元素可以重复
• 插入和删除快
• 查询速度一般

List的常见命令有：

• LPUSH key element ... : 向列表左侧插入一个或多个元素
• LPOP key: 移除并返回列表左侧的第一个元素，没有则返回nil
• RPUSH key element ...: 向列表右侧插入一个或多个元素
• RPOP key: 移除并返回列表右侧的第一个元素
• LRANGE key star end: 返回一段角标范围内的所有元素
• BLPOP和BRPOP：与LPOP和RPOP类似，只不过在没有元素时等待指定时间，而不是直接返回nil

如何利用List结构模拟一个栈？
入口和出口在同一边

如何利用List结构模拟一个队列？
入口和出口在不同边

如何利用List结构模拟一个阻塞队列？

2.6 Set类型

Redis的Set结构与Java中的HashSet类似，可以看作是一个value为null的HashMap。因为也是一个hash表，因此具备HashSet类似的特征：

• 无序
• 元素不可重复
• 查找快
• 支持交集，并集，差集等功能

Set类型的常见命令

• SADD key menber ...: 向set中添加一个或多个元素
• SREM key menber ... : 移除set中的指定元素
• SCARD key: 返回set中元素的个数
• SISMEMBER key member: 判断一个元素是否存在于set中
• SMEMBERS：获取set中的所有元素

多个集合间的操作

• SINTER key1 key2 ...: 求key1与key2的交集
• SDIFF key1 key2 ... : 求key1与key2的差集
• SUNION key1 key2 ...: 求key1和key2的并集

2.7 SortedSet类型

Redis的SortedSet是一个可排序的Set集合，与Java中的TreeSet有些类似，但底层数据结构却差别很大。SortedSet中的每一个元素都带有一个score属性，可以基于score属性对元素进行排序，底层的实现是一个跳表(SkipList)加hash表。
SortedSet具备如下特征：

• 可排序
• 元素不重复
• 查询速度快

因为SortedSet的可排序特性，经常被用来实现排行榜这样的功能。

SortedSet类型的常见命令:

• ZADD key score member: 添加一个或多个元素到sorted set,如果已经存在则更新其score值。
• ZREM key member: 删除sorted set中的一个指定元素。
• ZSCORE key member: 获取sorted set中指定元素的score值
• ZRANK key member: 获取sorted set中的指定元素的排名
• ZCARD key: 获取sorted set中元素个数
• ZCOUNT key min max: 统计score值在给定范围内的所有元素的个数。
• ZINCRBY key increment memver: 让sorted set中的指定元素自增，步长为指定的increment值。
• ZRANGE key min max: 按照score排序后，获取指定排名范围内的元素
• ZRANGEBYSCORE key min max: 按照score排序后，获取指定score范围内的元素

将班级的下列学生得分存入Redis的SortedSet中：
Jack 85, Lucy 89, Rose 82, Tom 95, Jerry 78, Amy 92, Miles 76

• 删除Tom同学

zrem stus Tom

• 获取Amy同学的分数

• 获取Rose同学的排名

zrank stus Rose 结果是要 + 1:降序
zrevrank stus Rose 结果是要 + 1：升序

• 查询80分一下有几个学生

zcount stus 0 80

• 给Amy同学加2分

zincrby stus 2 Amy

• 查出成家前3名的同学

zrevrange stus 0 2

• 查出成家80分以下的所有同学

zrangebyscore stus 0 80

03 Redis的Java客户端

3.1 常见Redis的Java客户端

Jedis

以Redis命令作为方法名称，学习成本低，简单实用。但是Jedis实例不是线程安全的，多线程环境下需要基于连接池来使用。

lettuce

Lettuce是基于Netty实现的，支持同步，异步和响应式编程方式，并且是线程安全的。支持Redis的哨兵模式，集群模式和管道模式。

Redisson

Redisson是一个基于Redis实现的分布式，可伸缩Java数据结构集合。包含了诸如Map, Queue, Lock, Semaphore, AtomicLong等强大功能。

Spring对于Redis的Java客户端进行了整合

3.2 Jedis

redis/jedis: Redis Java client designed for performance and ease of use. (github.com)

Jedis使用的基本步骤

1.引入依赖
2.创建Jedis对象，建立连接
3.使用Jedis，方法名与Redis命令一致
4.释放资源

依赖

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>4.2.0</version>
</dependency>

代码

@SpringBootTest
class DemoApplicationTests {
    
    private Jedis jedis;
    
    
    @BeforeEach
    void setUp(){
        //建立连接,
        //线程不安全，并发的情况，不能够这样使用，要依赖与线程池
//        jedis = new Jedis("192.168.65.100", 6379);
        jedis = JedisConnectionFactory.getJedis();
        //设置密码
//        jedis.auth("123321");
        //选择库
        jedis.select(0);
    }


    @Test
    void testString(){
        //插入数据库，
        String result = jedis.set("name", "initialie");
        System.out.println("result = " + result);

        //获取数据
        String name = jedis.get("name");
        System.out.println("name = " + name);
    }

    @Test
    void testHash(){
        //插入hash数据
        jedis.hset("user:1", "name", "Jack");
        jedis.hset("user:1", "age", "21");

        //获取
        Map<String, String> map = jedis.hgetAll("user:1");
        System.out.println(map);


    }


    @AfterEach
    void teatDown(){
        if(jedis != null){
            jedis.close();
        }
    }
}

public class JedisConnectionFactory {

    private static final JedisPool jedisPool;


    static{
        //配置连接池
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(8);
        poolConfig.setMaxIdle(8);
        poolConfig.setMinIdle(0);
        poolConfig.setMaxWaitMillis(1000);

        //创建连接池对象
        jedisPool = new JedisPool(poolConfig, "192.168.65.100", 6379, 1000);

    }

    public static Jedis getJedis(){
        return jedisPool.getResource();
    }

}

3.3 SpringDataRedis

SpringData是Spring中数据操作的模块，包含对各种数据库的集成，其中对Redis的集成模块叫做SpringDataRedis,官网地址：Spring Data Redis

• 提供了对不同Redis客户端的整合(Lettuce和Jedis)
• 提供了RedisTemple统一API来操作Redis
• 支持Redis的发布订阅模型
• 支持Redis哨兵和Redis集群
• 支持基于Lettuce的响应式编程
• 支持基于JDK，JSON，字符串，Spring对象的数据序列化及反序列化
• 支持基于Redis的JDKCollection实现

SpringDataRedis中提供了RedisTemplate工具类，其中封装了各种对Redis的操作。并且将不同的数据类型的操作API封装到不同的类中。

API	返回值类型	说明
redisTemplate.opsForValue()	ValueOperations	操作String类型数据
redisTemplate.opsForHash()	HashOperations	操作Hash类型数据
redisTemplate.opsForList()	ListOperations	操作List类型数据
redisTemplate.opsForSet()	SetOperations	操作Set类型数据
redisTemplate.opsForZSet()	ZSetOperations	操作SortedSet类型数据
redisTemplate		通用命令

依赖

        <!--spring data redis依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--commons-pool2 对象池依赖-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

appliction.yaml

spring:
  redis:
    host: 192.168.65.100
    port: 6379
    lettuce:
      pool:
        max-active: 8
        max-idle: 8
        min-idle: 0
        max-wait: 100ms

Test

@SpringBootTest
class DemoApplicationTests {
    

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void testString(){
        //写入一条String数据
        redisTemplate.opsForValue().set("name", "胡歌");
        //获取string数据
        Object name = redisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);
    }
}

3.4 SpringDataRedis的序列化方式

RedisTemplate可以接收任意Object作为值写入Redis，只不过写入前会把Object序列化为字节形式，默认是采用JDK序列化，得到的结果是这样的。

缺点

• 可读性差
• 占用内存较大

代码指定RedisTemplate指定序列化方式

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory){

        //创建RedisTemplate对象
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        //设置连接工厂
        template.setConnectionFactory(connectionFactory);
        //创建JSON序列化工具
        GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        //设置Key的序列化
        template.setKeySerializer(RedisSerializer.string());
        template.setHashKeySerializer(RedisSerializer.string());
        //设置Value的序列化
        template.setValueSerializer(jsonRedisSerializer);
        template.setHashValueSerializer(jsonRedisSerializer);
        //返回
        return template;
    }

@SpringBootTest
class DemoApplicationTests {
    

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Test
    void testString(){
        //写入一条String数据
        redisTemplate.opsForValue().set("name", "胡歌");
        //获取string数据
        Object name = redisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);
    }

    @Test
    void testSaveUser(){
        //写入数据
        redisTemplate.opsForValue().set("user:100", new User("胡歌",33));
        //获取数据
        User o = (User)redisTemplate.opsForValue().get("user:100");
        System.out.println("o = " + o);
    }


}

Redis客户端，图像化界面

为了节省内存空间，我们并不会使用JSON序列化器来处理value,而是统一使用String序列化器，要求只能存储String类型的Key和Value。当需要存储Java对象时，手动完成对象的序列化和反序列化。

3.5 StringRedisTemplate

Spring默认提供了一个StringRedisTemplate类，它的key和value的序列化方式默认就是String方式。省去了我们自定义RedisTemplate的过程。

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Test
    void testString(){
        //写入一条String数据
        stringRedisTemplate.opsForValue().set("name", "胡歌");
        //获取string数据
        Object name = stringRedisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);
    }

    private static final ObjectMapper mapper = new ObjectMapper();
    @Test
    void testSaveUser() throws JsonProcessingException {
        //创建对象
        User user = new User("胡歌2", 21);
        //手动序列化
        String json = mapper.writeValueAsString(user);

        //写入数据
        stringRedisTemplate.opsForValue().set("user:100", json);
        //获取数据
        String jsonUser = stringRedisTemplate.opsForValue().get("user:100");
        //手动反序列化
        User user1 = mapper.readValue(jsonUser, User.class);
        System.out.println("user1 = " + user1);
    }

RedisTemplate的两种序列化实践方案：
方案一：

1. 自定义RedisTemplate
2. 修改RedisTemplate的序列化器为GenericJackson2JsonRedisSerializer

方案二：

1. 使用StringRedisTemplate
2. 写入Redis时，手动把对象序列化为JSON
3. 读取Redis时，手动把读取到的JSON反序列化为对象

Hash

    @Test
    void testHash(){
        stringRedisTemplate.opsForHash().put("user:400", "name", "xiaoming");
        stringRedisTemplate.opsForHash().put("user:400", "age", "23");

        Map<Object, Object> entries = stringRedisTemplate.opsForHash().entries("user:400");
        System.out.println("entries = " + entries);
    }