redis

redis
安装Redis

环境：Linux 版本 CentOS 7
Redis官方地址: https://redis.io/
Redis 版本 6.2.7
Redis 下载地址：https://redis.io/download/

1. 安装Redis 依赖 – Redis是基于c语言写的，因此首先需要安装Redis所需的gcc依赖
```
yum install -y gcc tcl
1
```
2. 上传安装包并解压

将redis-6.2.7.tar.gz 放到 /usr/local/src 文件夹下解压
```
tar -zxvf redis-6.2.7.tar.gz
1
```
进入redis 目录：
```
cd redis-6.2.7
1
```
进行编译：
```
make && make install
1
```
如果没有出错，应该就安装成功了

默认安装路径是在 /usr/local/bin 目录：

该目录以及默认值配置到环境变量，因此可以在任意目录下运行这些命令。其中：
- redis-cli：是redis提供的命令行客户端
- redis-server：是redis的服务端启动脚本
- redis-sentinel：是redis的哨兵启动脚本
3. 启动 - - - 3种启动方式
1. 默认启动
```
redis-server
1
```
  查看redis 是否启动成功，换个窗口,查看下redis 进程
```
ps -ef | grep redis
1
```
  关闭进程 kill -9 [进程]
  
  这种启动属于前台启动，会阻塞整个对话窗口，窗口关闭按下Ctrl + C ,则Redis停止，不推荐使用。
2. 指定配置启动
  如果要让Redis 以后台方式启动，则必须修改Redis 配置文件，就在我们之前解压的redis 安装包下 /usr/local/src/redis-6.2.7的redis.conf
  现将这个配置文件备份一份：
```
cp redis.conf redis.conf.bck
1
```
  修改redis.conf 配置：
```
# 允许访问的地址，默认是127.0.0.1 会导致只能在本地访问，修改为0.0.0.0则可以在任意IP访问，生产环境下改回默认
bind 0.0.0.0
# 守护进程，修改为yes 后即可后台运行
daemonize yes
# 密码，设置后访问Redis 必须输入密码
requirepass 123456
1
2
3
4
5
6
```
  Redis 的其它常见配置：
```
# 监听的端口
port 6379
# 工作目录，默认是当前目录，也就是运行redis-server 时的命令，日志、持久化等文件会保存在这个目录
dir .
# 数据库数量，设置为1，代表只使用1个库，默认有16个库，编号0~15
databases 1
# 设置redis能够使用的最大内存
maxmemory 512mb
# 日志文件，默认为空，不记录日志，可以指定日志文件名
logfile "redis.log"
1
2
3
4
5
6
7
8
9
10
```
  启动Redis
```
# 进入redis 安装目录
cd /urs/local/src/redis-6.2.7
# 启动
reids-server redis.conf
1
2
3
4
```
  查看运行进程：
```
ps -ef | grep redis
1
```
  关闭reids, 可以kill redis 进程或者shutdown 停止服务
```
redis-cli -u 123456 shutdown
1
```
3. 开机自启
  通过配置来实现开机自启。
  新建一个系统服务文件：
```
vi /etc/systemd/system/redis.service
1
```
  文件内容：
```
[Unit]
Description=redis-server
After=network.target

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

[Install]
WantedBy=multi-user.target
1
2
3
4
5
6
7
8
9
10
11
```
  重载系统服务：
```
systemctl daemon-reload
1
```
  启动redis 服务
```
systemctl start redis
1
```
  查看redis 服务状态
```
systemctl status redis
1
```
  停止redis 服务
```
systemctl stop redis
1
```
  重启redis
```
systemctl restart redis
1
```
  执行下面命令，可以让reids 开机自启:
```
systemctl enable redis
1
```
Redis 客户端 - - - 3种客户端

1.命令行客户端
```
redis-cli [options] [commonds]
1
```
常见options 有：
- -h 127.0.0.1 指定连接redis 节点的IP 地址，默认127.0.0.1
- -p 6379 指定连接reids 节点的端口，默认6379
- -a 123456 指定redis 的访问密码
commonds 是redis 的操作命令，例如：
- ping 与reids服务端做心跳测试，服务端正常返回 pong
2.图形化桌面

Redis 的图形化桌面客户端地址：https://github.com/uglide/redisDesktopManager
该仓库未提供RedisDesktopManager的源码，并未提供windows安装包

在这个仓库可以找到安装包：https://github.com/lework/RedisdesktopManager-Windows/releases

resp 安装好后，打开连接设置

填好后，无法连接，因为没有开启linux防火墙端口
查询开放了哪些防火墙端口
```
firewall-cmd --zone=public --list-ports
1
```
开启6379端口号
```
firewall-cmd --zone=public --add-port=6379/tcp --permanent
1
```
刷新（重新加载端口号）
```
firewall-cmd --reload
1
```
查看6379端口号是否已经开启
```
firewall-cmd --query-port=6379/tcp
1
```
编辑防火墙配置文件:
```
vim  /etc/sysconfig/iptables-config
1
```
文件内容，添加如下：
```
-A INPUT -p tcp -m state --state NEW -m tcp --dport 80 -j ACCEPT
-A INPUT -p tcp -m state --state NEW -m tcp --dport 6379 -j ACCEPT
1
2
```
重启redis:
```
systemctl restart redis
1
```
RESP 连接成功后

 Redis 常见命令

1. Redis 数据结构介绍

Redis 是一个key-value数据库，keyi 一般是String 类型，value 类型多种多样：
基本类型：String、Hash 、List、 Set、 SortedSet
常见特殊类型：GEO 、BitMap、 HyperLog
Redis 将操作不同数据类型的命令做了分组，在官网中也可以查看到https://redis.io/commands/
```
help @list
help @string
1
2
```
2. Redis 通用命令
- KEYS：查看符合模板的所有key (生产上不建议使用)
- DEL：删除一个指定的key
- EXISTS：判断 key 是否存在
- EXPIRE：给一个key 设置有效期，有效期到期时刻key 会被自动删除
- TTL：查看一个key 的剩余有效期 -1 代表永久有效 -2 代表过期
3. String 类型

String 类型的三种格式：
value 是字符串，根据字符串格式不同，又可以分为3类：
- string：普通字符串
- int：整数类型，可以做自增、自减操作
- float：浮点类型，可以做自增、自减操作
  不管哪种格式，底层都是字节数组形式存储，只不过是编码方式不同。字符串类型的最大空间不能超过512m
String 类型的常见命令：
- SET：添加或者修改已经存在的一个String 类型的键值对
- GET：根据key 获取String 类型的value
- MSET：批量添加多个String 类型的value
- INCR：让一个整型的key 自增1
- INCRBY：让一个整型的key 自增并指定步长，例如：incrby num 2
- INCRBYFLOAT：让一个浮点类型的数字自增并指定步长
- SETNX：添加一个String 类型的键值对，前提是这个key 不存在，否则不执行
- SETEX：添加一个String 类型的键值对，并且指定有效期
Key的层级格式：
Redis 的key 允许有多个单词形成层级结构，多个单词之间用 :隔开，参考格式如下：
```
[项目名]:[业务名]:[类型]:[id]
1
```
例如：
```
taobao:personcenter:user:1
1
```
4. Hash 类型

Hash 类型，也叫散列，其value 是一个无序字典，类似于java 中的HashMap 结构。
String 结构是将对象序列化JSON 字符串后存储，当需要修改为对象某个字段时很不方便。
Hash 结构可以将对象中的每个子u但独立存储，可以针对单个字段做CRUD
Hash 类型的常见命令：
- 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
- HVALUES：获取一个hash 雷丁的key 中的多有的value
- HINCRBY：让一个hash 类型key 的字段值自增并指定步长
- HSETNX：添加一个hash 类型的key 的field 值，前提时这个field 不存在，否则不执行
5. List 类型

Redis 中的List 类型与java 中的LinkedList 类似，可以看做是一个双向链表结构，既可以支持正向检索和也可以支持反方向检查。
特征也与LinkedList 类似：
- 有序
- 元素可以重复
- 插入和删除快
- 查询速度一般
List 类型的常见命令：
- LPUSH key element ... ：向列表左侧插入一个或多个元素
- LPOP key：移除并返回列表左侧的第一个元素，没有则返回nil
- RPUSH key element ...：向列表右侧插入一个或多个元素
- RPOP key：移除并返回列表右侧的第一个元素
- LRANGE key start end：返回一段角标范围内的所有元素
- BLPOP 和 BRPOP ：与LPOP和RPOP类似，只不过在没有元素时等待指定时间，而不是直接返回nil
利用List 结构模拟一个栈：
- 入口和出口在同一边 (LPUSH,LPOP)
利用List 结构模拟一个队列：
- 入口和出口在不同边(LPUSH,RPOP)
利用List 结构模拟一个阻塞队列：
- 入口和出口在不同边
- 出队时采用BLPOP或BRPOP
6. Set 类型

Redis 的Set 结构与java 中的HashSet 类似，可以看作是一个value 为null 的HashMap。因为也是一个hash 表，因此具备与 HashSet 类似的特征：
- 无序
- 元素不可重复
- 查找快
- 支持交集、并集、差集等功能
Set 类型的常见命令：
- SADD key member ...：向set 中添加一个或多个元素
- SREM key member ...：移除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 的并集
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 中指定元素的排名
- ZCRAD key：获取sorted set 中的元素个数
- ZCOUNT key min max：统计score 值在给定范围内的所有元素的个数
- ZINCRBY key increment member：让sorted set 中的指定元素自增，步长为指定的increment 值
- ZRANGE key min max：按照score 排序后，获取指定排名范围内的元素
- ZRANGEBYSCORE key min max：按照score 排序后，获取指定score 范围内的元素
- ZDIFF、ZINTER、ZUNION：求差集、交集、并集
注意：所有的排名默认都是升序，如果要降序则在命令的Z的后面添加REV即可

 编程客户端

Redis 的Java 客户端，地址：https://redis.io/docs/clients/#java

1.Jedis

Jedis的官网地址：https://github.com/redis/jedis
Jedis简单那使用：
```
<dependency>
     <groupId>redis.clients</groupId>
     <artifactId>jedis</artifactId>
     <version>4.2.0</version>
</dependency>
1
2
3
4
5
```
```
@SpringBootTest
class JedisDemoApplicationTests {

    private Jedis jedis;

    @BeforeEach
    void setUp() {
        jedis = new Jedis("192.168.241.128", 6379);
        jedis.auth("123456");
        jedis.select(0);
    }

    @Test
    void testString() {
        //存数据
        String result = jedis.set("name", "张三");
        System.out.println("result = " + result);
        //取数据
        String name = jedis.get("name");
        System.out.println("name =" + name);
    }

    @Test
    void testHash() {
        //插入hash 数据
        jedis.hset("user:1","name","张三");
        jedis.hset("user:1","age","20");
        //获取数据
        Map<String, String> map = jedis.hgetAll("user:1");
        System.out.println(map);
    }

    @AfterEach
    void tearDown() {
        if (jedis != null){
            jedis.close();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
```
Jedis 本身是线程不安全的，并且频繁的创建和销毁连接会有性能损耗，因此推荐使用Jedis连接池代替Jedis 的直连方式。
```
public class JedisConnectionFactory {
    private static final JedisPool jedisPool;

    static {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        //最大连接数
        jedisPoolConfig.setMaxTotal(8);
        //最大空闲连接
        jedisPoolConfig.setMaxIdle(8);
        //最小空闲连接
        jedisPoolConfig.setMinIdle(0);
        //设置最长等待时间
        jedisPoolConfig.setMaxWaitMillis(200);
        jedisPool = new JedisPool(jedisPoolConfig,"192.168.241.128",6379,1000,"123456");
    }

    /**
     * 获取Jedis 对象
     * @return
     */
    public static Jedis getJedis(){
        return jedisPool.getResource();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
```
```
@SpringBootTest
class JedisDemoApplicationTests {

    private Jedis jedis;

    @BeforeEach
    void setUp() {
        jedis = JedisConnectionFactory.getJedis();
        jedis.auth("123456");
        jedis.select(0);
    }

    @Test
    void testString() {
        //存数据
        String result = jedis.set("name", "张三");
        System.out.println("result = " + result);
        //取数据
        String name = jedis.get("name");
        System.out.println("name =" + name);
    }

    @Test
    void testHash() {
        //插入hash 数据
        jedis.hset("user:1","name","张三");
        jedis.hset("user:1","age","20");
        //获取数据
        Map<String, String> map = jedis.hgetAll("user:1");
        System.out.println(map);
    }

    @AfterEach
    void tearDown() {
        if (jedis != null){
            jedis.close();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
```
2.SpringDataRedis

SpringData 是Spring 中数据操作的模块，包含对各种数据库的集成，其中对Redis 的集成模块就叫做SpringDataRedis，官网地址：https://spring.io/projects/spring-data-redis
- 提供了对不同Redis 客户端的整合（Lettuce 和 Jedis)
- 提供了RedisTemplate 统一API来操作Redis
- 支持Redis 的发布订阅模型
- 支持Redis 哨兵和Redis 集群
- 支持基于Lettuce 的响应式编程
- 支持基于JDK、JSON、字符串、Spring 对象的数据序列化及反序列化
- 支持基于Redis 的JDKCollection 实现
SpringDataRedis简单使用：
```
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <version>2.7.1</version>
</dependency>

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>
1
2
3
4
5
6
7
8
9
10
```
```
spring:
  redis:
    host: 192.168.241.128
    port: 6379
    password: 123456
    lettuce:
      pool:
        max-active: 8 # 最大连接
        max-idle: 8 # 最大空闲连接
        min-idle: 0 # 最小空闲连接
        max-wait: 100 # 连接等待时间
1
2
3
4
5
6
7
8
9
10
11
```
```
@SpringBootTest
class RedisApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void testString() {
        //插入数据
        redisTemplate.opsForValue().set("name", "王五");
        //获取数据
        Object name = redisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
```
RedisTemplate 的序列化方式一：<缺点：多存入class 名>
```
@Configuration
public class RedisConfig {

    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        // 创建RedisTemplate 对象
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        // 设置连接工厂
        template.setConnectionFactory(factory);
        // 创建Json序列化工具
        GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        // 设置key 的序列化
        template.setKeySerializer(jackson2JsonRedisSerializer);
        template.setHashKeySerializer(jackson2JsonRedisSerializer);
        // 设置value 的序列化
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        return template;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
```
```
@SpringBootTest
class RedisApplicationTests {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Test
    void testString() {
        //插入数据
        redisTemplate.opsForValue().set("name", "王五");
        //获取数据
        Object name = redisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);
    }

    @Test
    void testSaveUser() {
        redisTemplate.opsForValue().set("user:2",new User("李四",20));
        User user = (User) redisTemplate.opsForValue().get("user:2");
        System.out.println("user = " + user);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
```
为了节省空间，我们并不回使用JSON 序列化器来处理value, 而是统一使用String 序列化器，要求只能存储String 类型的key 和value。当需要存储Java 对象时，手动完成对象的序列化和反序列化。

RedisTemplate 的序列化方式二：
Spring 默认提供了一个StringRedisTemplate 类，它的key 和 value 的序列化方式默认就是String 方式。省去了自定义RedisTemplate 过程。
```
    @Autowired(required = false)
    private StringRedisTemplate stringRedisTemplate;

    // JSON 工具
    private static final ObjectMapper mapper = new ObjectMapper();

    @Test
    void testStringTemplate() throws JsonProcessingException {
        // 手动序列化
        String json = mapper.writeValueAsString(new User("李四", 20));
        // 写入数据
        stringRedisTemplate.opsForValue().set("user:2",json);
        // 获取数据
        String val = stringRedisTemplate.opsForValue().get("user:2");
        // 手动反序列化
        User user = mapper.readValue(val, User.class);
        System.out.println("user = " + user);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
```
缓存击穿

缓存击穿是指热点key在某个时间点过期的时候，而恰好在这个时间点对这个Key有大量的并发请求过来，从而大量的请求打到db。

缓存雪崩

缓存雪崩是指缓存中数据大批量到过期时间，而查询数据量巨大，引起数据库压力过大甚至down机。
相关阅读:
Linux运维10：scp命令详解
 k8s--基础--12.1--pod--概念
 MySQL数据库——SQL语言
 自定义element-ui plus 函数式调用，在API，js中直接使用全局组件
 基于遗传算法的PID控制器增益的实现(Matlab代码实现）
props对象写法
 vue-router导入视图文件方式与打包参数的差异
 蓝桥等考Python组别十五级004
对max2900的一些了解
 centos7创建ramdisk
原文地址：https://blog.csdn.net/AliEnCheng/article/details/126500428

安装Redis

1. 安装Redis 依赖 – Redis是基于c语言写的，因此首先需要安装Redis所需的gcc依赖

2. 上传安装包并解压

3. 启动 - - - 3种启动方式

Redis 客户端 - - - 3种客户端

1.命令行客户端

2.图形化桌面

Redis 常见命令

1. Redis 数据结构介绍

2. Redis 通用命令

3. String 类型

4. Hash 类型

5. List 类型

6. Set 类型

7. SortedSet类型

编程客户端

1.Jedis

2.SpringDataRedis

缓存击穿

缓存雪崩