Redis 基础篇笔记

Linux 环境下 Redis 的安装和配置

---

第一步：安装 Redis 依赖

Redis 是基于C语言编写的，因此首先需要安装Redis所需要的 gcc 依赖

yum install -y gcc tcl

第二步：上传安装包并解压

---

• 把 redis.tar.gz 安装包随便丢到 Linux 的一个目录中

  

• 然后解压缩

#解压到当前文件夹
tar -xzf redis-6.2.6.tar.gz

• 然后进入 redis 目录

cd redis-6.2.6

• 运行编译命令安装
  • 默认安装路径 /usr/local/bin 可以用 ll /usr/local/bin 查看是否安装成功

make && make install

该目录以及默认配置到环境变量，因此可以在任意目录下运行这些命令。其中：

• redis-cli：是redis提供的命令行客户端
• redis-server：是redis的服务端启动脚本
• redis-sentinel：是redis的哨兵启动脚本

第三步：启动 redis

---

第一种启动方式 【默认启动】

安装完成后，在任意目录输入redis-server命令即可启动Redis

这种启动属于前台启动，会阻塞整个会话窗口，窗口关闭或者按下CTRL + C则Redis停止。不推荐使用。

第二种启动方式【指定配置启动】

如果要让 Redis 以后台方式启动，则必须修改Redis配置文件，就在我们之前解压的 redis 安装包下，名字叫 redis.conf

• 先把配置文件备份

cp redis.conf redis.conf.bck

• 然后修改 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

# 进入redis安装目录 注意这里是自己的安装目录不是我的！！！
cd /home/mangfu/redis-6.2.6/
# 启动
redis-server redis.conf

• 停止服务

# 利用redis-cli来执行 shutdown 命令，即可停止 Redis 服务，
# 因为之前配置了密码，因此需要通过 -u 来指定密码redis-cli -u 123321 shutdown# 或者直接杀掉进程也可以
#查看 redis 相关进程
ps -ef | grep redis
# 杀掉 redis 进程
kill -9 进程号

redis.conf 其他常用配置

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

第三种方式【开机自启动】

先关闭 redis 进程再操作

• 新建一个系统服务文件

vim /etc/systemd/system/redis.service

[Unit]
Description=redis-server
After=network.target[Service]
Type=forking
#第一条是你 `redis-server` 所在位置
#第二条是你 `redis.conf` 所在位置
ExecStart=/usr/local/bin/redis-server /home/mangfu/redis-6.2.6/redis.conf
PrivateTmp=true[Install]
WantedBy=multi-user.target

• 然后重载系统服务

systemctl daemon-reload

• 然后设置 redis 开机自启

systemctl enable redis

现在我们可以用这组命令操作 redis 了

# 启动
systemctl start redis
# 停止
systemctl stop redis
# 重启
systemctl restart redis
# 查看状态
systemctl status redis

Redis 客户端

Redis 命令行客户端

---

Redis 安装完成后就自带了命令行客户端：redis-cli

redis-cli [options] [commonds]

其中常见的options有：

• -h 127.0.0.1：指定要连接的redis节点的IP地址，默认是127.0.0.1
• -p 6379：指定要连接的redis节点的端口，默认是6379
• -a 123321：指定redis的访问密码

cli 选择仓库用 select 仓库号 选择仓库

options 都不指定

• -h 默认就是 127.0.0.1
• -p 默认就是 6379
• -a 可以输入 auth 密码 验证

用 ping 测试是否连通

图形化桌面客户端 RESP

---

• 下载软件

https://github.com/lework/RedisDesktopManager-Windows/releases

• 然后在 linux 中开放 6379 端口防火墙

# 检查 firewalld 服务状态
systemctl status firewalld
# 如果未运行，使用以下命令启动
systemctl start firewalld
# 设置 firewalld 开机自启
systemctl enable firewalld# 开放 6379 端口（TCP 协议），--permanent 表示永久生效
firewall-cmd --zone=public --add-port=6379/tcp --permanent
# 重新加载防火墙规则使配置生效
firewall-cmd --reload#验证端口是否生效
firewall-cmd --zone=public --list-ports

• 然后建立连接
  • 名字随意
  • 地址用 linux 中 ip addr 查出来的 ip
  • 密码就是你设置的 redis 密码

Redis 常用命令

Redis 数据结构概述

---

Redis 通用命令

---

• KEYS pattern： 查看符合模板的所有 key
• DEL key...：删除指定的 key
• EXISTS key...：判断 key 是否存在
• EXPIRE key seconds：给一个 key 设置有效期，有效期一到自动删除**
• TTL key：查看一个 KEY 的剩余有效期

通过 help [command] 可以查看命令具体用法

Key 的层级结构

---

假如需要存储用户.商品信息到 redis，有一个用户 id 是 1，有一个商品 id 恰好也是 1，此时如果使用 id 作为 key，那就会冲突了

一旦我们向redis采用这样的方式存储，那么在可视化界面中，redis 会以层级结构来进行存储，形成类似于这样的结构，更加方便 Redis 获取数据

String 类型数据

---

以上命令除了 INCRBYFLOAT 都是常用命令

SET： 如果 key 不存在则是新增，如果存在则是修改

Hash 类型数据

---

List 类型数据

---

Set 类型数据

SortedSet 类型数据

滚动分页

• ZRANGEBYSCORE key min max [ WITHSCORES LIMIT 小于等于最大值的第一个元素，查几个元素 ]

//第一次查询固定 最大值 1000, 最小值 0 从 第一个元素开始查 查 3 个
ZRANGEBYSCORE z1 1000 0 WITHSCORES LIMIT 0 3

举例

数据
key z1
"m8" 8
"m7" 7
"m6" 6
"m6" 6
"m5" 5
"m4" 4
"m3" 3最大值
第一次查询 3 条数据
ZRANGEBYSCORE z1 1000 0 WITHSCORES LIMIT 0 3
"m8" 8
"m7" 7
"m6" 6第二次查询 3 条数据 出现重复数据了因为我们 LIMIT 后第一个参数 小于等于最大值的第一个元素 
我们常规是 + 1 也就是 0 变成 1 了 但是小于等于最大值的第一个元素 6 有两个 我们 + 1 还是 6
ZRANGEBYSCORE z1 6 0 WITHSCORES LIMIT 1 3
"m6" 6
"m5" 5
"m4" 4解决第二次查询: 我们的方案是 LIMIT 后第一个参数 改成 小于等于最大值的第一个元素的个数
ZRANGEBYSCORE z1 6 0 WITHSCORES LIMIT 2 3 这样就不会重复了
"m5" 5
"m4" 4
"m3" 3公式总结    
- 第一次查询: ZRANGEBYSCORE z1 1000 0 WITHSCORES LIMIT 0, 要查询的条数
- 后面的所有查询: ZRANGEBYSCORE z1 上一次查询的最小值 0 WITHSCORES LIMIT 小于等于最大值的第一个元素的个数, 要查询的条数   这是针对排序反转的情况。正常排序也是一样的思路    

• java 代码

stringRedisTemplate.opsForZet().RangeByScoreWithScores(key, min, max, offset, count)排序反转    
stringRedisTemplate.opsForZet().reverseRangeByScoreWithScores(keym, min max, offset, count) 

BitMap 数据类型

---

// 向指定位置存一个 0 或 1。如果跳过了某个位置就默认是 0 
SETBIT bm1 0 1
"0"
SETBIT bm1 1 1
"0"
SETBIT bm1 5 1
"0"
SETBIT bm1 6 1
"0"
SETBIT bm1 7 1
"0"
-----------
java操作 0表示指定位置, true 表示 1 
stringRedisTemplate.opsForValue().setBit(key, 0, true);//查询指定位置的 bit 值
GETBIT bm1 0
"1"//统计 BitMap 中值为 1 的 bit 位的数量
BITCOUNT bm1
"5"//把某几位二进制转为 10进制
//u2 表示无符号 2 bit位 , 0就是从索引 0 开始获取
BITFIELD bm1 GET u2 0 
"3"---------java代码
从获取 0 到 14 位二进制数，然后转为十进制
stringRedisTemplate.opsForValue().bitField(key,BitFieldSubCommands.create().get(BitFieldSubCommands.BitFieldType.unsigned(14)).valueAt(0)  //获取bit数组指定范围的内一个 0 出现的位置 
//不指定返回就是从头查到尾
BITPOS bm1 0

HyperLogLog 数据类型

• PFADD：向指定的 HHL(key) 中添加元素。
• PFCOUNT：估算一个或多个 HLL(key) 的近似基数（不重复元素数量）。
• PFMERGE：合并多个 HLL(key) 到一个新的 HLL(key) 中。

不管加入多少重复元素，都只统计一次

Java 操作 Redis

Jedis

---

第一步：引入 Jedis 依赖

<!--jedis-->
<dependency><groupId>redis.clients</groupId><artifactId>jedis</artifactId><version>3.7.0</version>
</dependency><!--单元测试-->
<dependency><groupId>org.junit.jupiter</groupId><artifactId>junit-jupiter</artifactId><version>5.7.0</version><scope>test</scope>
</dependency>

第二步：建立连接

   private Jedis jedis;@BeforeEachvoid setup() {//1. 建立和 linux redis 的 ip 和 端口jedis = new Jedis("192.168.88.130", 6379);//2. 设置密码jedis.auth("Ting123321");//3. 选择库jedis.select(0);}

第三步：按照正常 Redis 语法操作

 @Testvoid testString() {//存入数据String result = jedis.set("name", "虎哥");System.out.println("result = " + result);//获取数据String name = jedis.get("name");System.out.println("name = " + name);}@Testvoid testHash() {// 插入 hash 数据jedis.hset("user:1", "name", "Jack");jedis.hset("user:1", "age", "21");// 获取 hash 数据//field 和 value 是一个 Map 类型数据Map<String, String> map = jedis.hgetAll("user:1");System.out.println(map);}

Jedis 连接池

• 创建连接池工厂

public class JedisConnectionFacotry {private static final JedisPool jedisPool;static {//创建配置连接池对象JedisPoolConfig poolConfig = new JedisPoolConfig();//最大连接poolConfig.setMaxTotal(8);//最大空闲连接poolConfig.setMaxIdle(8);//最小空闲连接poolConfig.setMinIdle(0);//设置最长等待时间, mspoolConfig.setMaxWaitMillis(1000);//创建连接池对象//参数: 配置连接池对象, //		 有 redis 的 linux 的 ip 地址//      redis 端口号//      尝试连接的等待时间 ms 这里就是 1s//      redis 的密码jedisPool = new JedisPool(poolConfig,"192.168.150.101",6379,1000,"123321");}//返回连接池对象public static Jedis getJedis(){return jedisPool.getResource();}
}

• 使用连接池对象

  @BeforeEachvoid setUp(){//建立连接/*jedis = new Jedis("127.0.0.1",6379);*///从连接池获取连接对象jedis = JedisConnectionFacotry.getJedis();//选择库jedis.select(0);}@AfterEachvoid tearDown() {//把连接对象归还连接池if (jedis != null) {jedis.close();}}

SpringDataRedis

---

RedisTemplate 操作语法

操作字符串类型数据

  /*** 操作字符串类型*/@Testpublic void testString() {//set get setex setnx//set: 设置指定key的值redisTemplate.opsForValue().set("city", "北京");String city = (String) redisTemplate.opsForValue().get("city");System.out.println(city);//setex: 设置指定key的值，并指定过期时间redisTemplate.opsForValue().set("city", "上海", 60, TimeUnit.MINUTES);//setnx: 设置指定key的值，如果key不存在，则设置成功，如果key存在，则设置失败redisTemplate.opsForValue().setIfAbsent("lock", "1");redisTemplate.opsForValue().setIfAbsent("lock", "2");String lock = (String) redisTemplate.opsForValue().get("lock");//icr: 整形 key 自增 1//对 key 位 key1 的 的值执行自增操作redisTemplate.opsForValue().increment("key1");}

操作哈希类型数据

/*** 操作 hash类型*/@Testpublic void testHash() {//hset hget hdel hkeysHashOperations hashOperations = redisTemplate.opsForHash();//hset: 设置指定key的hash值hashOperations.put("100", "name", "张三");hashOperations.put("100", "age", "20");//hget: 获取指定key的hash值String name = (String) hashOperations.get("100", "name");System.out.println(name);System.out.println("--------------");//hkey-hvals: 获取指定key的hash的所有kSet keys = hashOperations.keys("100");for (Object key : keys) {System.out.println(key);}System.out.println("--------------");//hvals: 获取指定key的hash的所有vList values = hashOperations.values("100");System.out.println(values);System.out.println("--------------");//hdel: 删除指定key的 k-v 值hashOperations.delete("100", "age");}

操作列表类型数据

/*** 操作列表类型的数据*/@Testpublic void testList(){//lpush lrange rpop llenListOperations listOperations = redisTemplate.opsForList();//lpush: 将一个或多个值插入列表listOperations.leftPushAll("mylist","a","b","c");listOperations.leftPush("mylist","d");//lrange: 返回列表返回的值List mylist = listOperations.range("mylist", 0, -1);System.out.println(mylist);//rpop: 移除并返回列表最后一个值listOperations.rightPop("mylist");//llen: 获取列表元素个数Long size = listOperations.size("mylist");System.out.println(size);}

操作集合类型数据

   /*** 操作集合类型的数据*/@Testpublic void testSet(){//sadd smembers scard sinter sunion sremSetOperations setOperations = redisTemplate.opsForSet();//sadd: 向某个集合中添加元素setOperations.add("set1","a","b","c","d");setOperations.add("set2","a","b","x","y");//smembers: 获取某个集合中的所有元素Set members = setOperations.members("set1");System.out.println(members);//scard: 获取某个集合中的元素个数Long size = setOperations.size("set1");System.out.println(size);//sinter: 求交集Set intersect = setOperations.intersect("set1", "set2");System.out.println(intersect);//sunion: 求并集Set union = setOperations.union("set1", "set2");System.out.println(union);//srem: 移除集合中的元素setOperations.remove("set1","a","b");}
}

操作有序集合类型数据

  /*** 操作有序集合类型的数据*/@Testpublic void testZset(){//zadd zrange zincrby zremZSetOperations zSetOperations = redisTemplate.opsForZSet();//zadd: 向有序集合中添加元素//默认从score小到大排序zSetOperations.add("zset1","a",10);zSetOperations.add("zset1","b",12);zSetOperations.add("zset1","c",9);//zrange: 获取有序集合中指定范围的元素Set zset1 = zSetOperations.range("zset1", 0, -1);System.out.println(zset1);//zincrby: 为有序集合中的元素增加分数zSetOperations.incrementScore("zset1","c",10);//zrem: 移除有序集合中的元素zSetOperations.remove("zset1","a","b");}

通用命令

    /*** 通用命令操作*/@Testpublic void testCommon(){//keys exists type del//keys: 获取所有符合给定模式的键Set keys = redisTemplate.keys("*");System.out.println(keys);//exists: 判断给定key是否存在Boolean name = redisTemplate.hasKey("name");Boolean set1 = redisTemplate.hasKey("set1");//type: 返回给定key的类型for (Object key : keys) {DataType type = redisTemplate.type(key);System.out.println(type.name());}//del: 删除给定keyredisTemplate.delete("mylist");//expire key 时间: 设置有效期//三个参数一个 key, 一个时间, 一个时间单位stringRedisTemplate.expire(key, 2, TimeUnit.MINUTES);}
}

第一步：引入依赖

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

第二步：配置文件

spring:date:redis:host: 192.168.150.101 #有 redis 的 linux 的 ip 地址port: 6379  #redis 端口号password: 123321 #redis 密码lettuce: #选择底层 lettuce 方式pool: #配置连接池max-active: 8  #最大连接max-idle: 8   #最大空闲连接min-idle: 0   #最小空闲连接max-wait: 1000 #连接等待时间

第三步：注入 RedisTemplate 编写测试

默认序列化到 redis 里面是转换成字节 ，也就是使用 JDK 默认序列化器，导致可读性差，内存占用较大，还会出现一些 bug 比如 get 不到想要的数据

第四步：配置 Redis 序列化器

原理就是改变这四个 Redis 序列化对象

• Value 如果有可能是对象就用 GenericJackson2JsonREdisSerializer
• Key 和 Value 都确定是字符串就用
  .
  .
  StringRedisSerializer
  这种配置 Value 的方式有潜在问题，后期我们 K-V 都配为 Stirng，可以使用 StringRedisTemplate不用手动配置

• 配置 Redis 序列化器

@Configuration
public class RedisConfig {@Beanpublic RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory){// 创建RedisTemplate对象RedisTemplate<String, Object> template = new RedisTemplate<>();// 设置连接工厂template.setConnectionFactory(connectionFactory);// 创建JSON序列化工具GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer();// 设置Key 和 hashkey 采用 String 序列化template.setKeySerializer(RedisSerializer.string());template.setHashKeySerializer(RedisSerializer.string());// 设置 value 和 hashValue 采用JSON的序列化template.setValueSerializer(jsonRedisSerializer);template.setHashValueSerializer(jsonRedisSerializer);// 返回return template;}
}

• 重新注入 RedisTemplate

@SpringBootTest
class RedisDemoApplicationTests {//这里注入自己配置的 RedisTemplate@Autowiredprivate RedisTemplate<String, Object> redisTemplate;@Testvoid testString() {redisTemplate.opsForValue().set("name", "胡歌");System.out.println(redisTemplate.opsForValue().get("name"));}@Testvoid testSaveUser() {// 写入数据redisTemplate.opsForValue().set("user:100", new User(21, "胡歌"));//获取数据User user = (User) redisTemplate.opsForValue().get("user:100");System.out.println(user);}}

第五步：序列化的潜在问题和改进

• 用 FastJson 等工具进行序列化或反序列化 JSON 格式

总结