Redis数据库快速入门

向右看齐 2024-03-16 15:45 100阅读 0赞

**介绍：**

Redis：非关系型缓存数据库

*  nosql：非关系型数据库
    
     *  没有表，没有表与表之间的关系，更不存在外键
     *  存储数据的形式为key：values的形式
     *  c语言写的服务（监听端口），用来存储数据的，数据是存储在内存中，取值，放值速度非常快， 10w qps
 *  缓存数据库：
    
     *  数据存储在内存中
     *  大部分时间用于缓存，也可以长久存储数据
 *  redis速度为什么这么快：
    
     *  纯内存操作
     *  网路模型使用的IO多路复用（可以处理的请求更多）
     *  6.x版本之前，单进程，单线程，不存在进程线程之间切换，更少消耗资源

![字符串类型使用-2.png][-2.png]

### **1、redis的安装与运行** ###

**版本选择：**

*  mac：源码编译安装
 *  linux：源码编译安装
 *  windows：
    
     *  redis没有windows的版本，只有微软基于源码改动，编译的安装包（用法一样）
     *  3.x版本 [Releases · microsoftarchive/redis · GitHub][Releases _ microsoftarchive_redis _ GitHub]
     *  最新5.x版本 [Releases · tporadowski/redis · GitHub][Releases _ tporadowski_redis _ GitHub]

**安装：**

![42fbd1cdb715685b27e53d0313bf6017.png][]

**redis需要了解的目录结构：**

*  redis-server ：服务端启动文件
 *  redis-cli：客服端启动文件
 *  redis.windows-service.conf：默认使用的配置文件
    
     *  bind 127.0.0.1 ：服务端跑在的地址
     *  port 6379 ：占用的端口号

**启动redis：**

*  方式一：将服务端添加至系统服务（电脑运行自动启动）  
    \*
 *  方式二：cmd终端使用命令启动
    
     *  redis-server 指定配置文件 \# 如果不指定，会默认

**客服端链接redis：**

*  cmd终端使用命令
    
     *  方式一：redis-cli 默认链接本地的6379端口
     *  方式二：redis-cli -h 地址 -p 端口

### **2、RESP图形化操作文件** ###

**可以使用软件：**

<code class="language-python">Redis Desktop Manager ：开源的，原来免费，后来收费了 推荐用（mac,win,linux 都有）
 
 -Qt5 qt是个平台，专门用来做图形化界面的 
 -可以使用c++写
 -可以使用python写 pyqt5 使用python写图形化界面 (少量公司再用)
 
 -resp-2022.1.0.0.exe 一路下一步，安装完启动起来
 
 -Redis Client 小众
 </code>

**RESP操作redis：**

![c909130709008a1be1a325c1ded88a6e.png][]

## **二、pycharm操作redis** ##

**安装模块:**

使用pycharm操作redis，pycharm相当于客户端，输入redis命令即可对数据库进行操作

<code class="language-python"># 下载模块：
 	pip install redis
 
 # 补充：django 中操作mysql，没有连接池的，一个请求就是一个mysql连接
 -可能会有问题，并发数过高，导致mysql连接数过高，影响mysql性能
 -使用django连接池：https://blog.51cto.com/liangdongchang/5140039
 </code>

### **1、Redis普通连接和连接池** ###

**普通链接：**

普通链接是指，直接操作redis，每一次操作都会建立一条链接

<code class="language-python"># 导入模块
 from redis import Redis
 
 # 实例化对象（后方参数填写链接的地址和端口，还可以填写其他参数）
 conn = Redis(host='127.0.0.1', port=6379)
 
 # 向redis中存放一个数据
 conn.set('name', 'kangkang')
 
 # 从redis中取出存放的数据(二进制格式)
 print(conn.get('name'))
 
 # 操作完成，手动关闭，不然会一直占用一条链接
 conn.close()
 </code>

**连接池连接：**

拿到一个Redis实例的连接池，避免每次建立、释放连接的开销，节省了每次连接用的时间，文中设置了最大10个。

**POOL.py**

<code class="language-python"># 1、使用单例模式（保证每次使用的都是同一个实例对象），设置连接池最大为10个
 import redis
 
 POOL = redis.ConnectionPool(
 # 最大链接
 max_connections=10,
 # 指定服务端地址
 host='127.0.0.1',
 prot=6379
 )
 </code>

**my\_redis.py**

<code class="language-python"># 导入redis
 from redis import Redis
 # 导入线程模块（模仿多线程并发）
 from threading import Thread
 # 导入自己创建的单例
 from script.pool import POOL
 
 
 # 写一个函数，在内部操作redis
 def task():
 # 以后生成的对象都是POLL这一个实例化的对象
 conn = Redis(connection_pool=POOL)
 conn.set('name', 'kangkang')
 print(conn.get('name'))
 
 if __name__ == '__main__':
 for i in range(100):
 t = Thread(target=task)
 t.start()
 </code>

### **2、Redis数据类型** ###

**介绍：**

redis 是key-value形式存储

redis 数据放在内存中，如果断电，数据丢失---》需要有持久化的方案

<table> 
 <thead> 
 <tr> 
 <th style="background-color:#fafafa;text-align:center;">类型</th> 
 <th style="background-color:#fafafa;text-align:center;">介绍</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td style="border-color:#c0c0c0;text-align:center;">字符串（string）</td> 
 <td style="border-color:#c0c0c0;text-align:center;">用的最多，做缓存；做计数器</td> 
 </tr> 
 <tr> 
 <td style="border-color:#c0c0c0;text-align:center;">列表（list）</td> 
 <td style="border-color:#c0c0c0;text-align:center;">常用于消息队列</td> 
 </tr> 
 <tr> 
 <td style="border-color:#c0c0c0;text-align:center;">字典（hash）</td> 
 <td style="border-color:#c0c0c0;text-align:center;">缓存</td> 
 </tr> 
 <tr> 
 <td style="border-color:#c0c0c0;text-align:center;">集合（set）</td> 
 <td style="border-color:#c0c0c0;text-align:center;">去重</td> 
 </tr> 
 <tr> 
 <td style="border-color:#c0c0c0;text-align:center;">有序集合（zset）</td> 
 <td style="border-color:#c0c0c0;text-align:center;">排行榜</td> 
 </tr> 
 </tbody> 
</table>

#### **2、1.String类型** ####

<code class="language-python"># 1、set(name, value, ex=None, px=None, nx=False, xx=False)
 ex：过期时间（秒）
 px：过期时间（毫秒）
 nx：如果设置为True，则只有name不存在时，当前set操作才执行, 值存在，就修改不了，执行没效果
 xx：如果设置为True，则只有name存在时，当前set操作才执行，值存在才能修改，值不存在，不会设置新值
 
 # 2、setnx(name, value) 
 	等同于set('name','kangkang',nx=True)
 
 # 3、setex(name,time,values)
 	等同于set('name',10,'kangkang')
 
 # 4、psetex(name,time_ms,values)
 	conn.psetex('name',3000,'kangkang')
 
 # 5、mset(*args,**kwargs)
 	可以批量存入数据
 	conn.mset({'name':'kangkang','age':18})
 
 # 6、get(name)
 	取值(单个)
 	coon.get('name')
 
 # 7、mget(keys, *args)
 	批量取值（可以是列表）
 	coon.mget('name','age')
 	coon.mget(['name','age'])
 
 # 8、getset(name, value)
 	放置新的值进入（可以使用变量接收被替换的值）
 	res = coon.getset('name','jason')
 	
 # 9、getrange(key, start, end)
 	按照指定key对应值的索引位置取值（按字节取值）
 	res = coon.gettrange('name',0 ,3)
 
 # 10、settrange(name, offset, value)
 	按照索引位置替换指定key对应的值（按照字节）
 	coon.settrange('name',3,'bbb')
 
 ---- 比特位---操作----
 # 11 setbit(name, offset, value)
 # 12 getbit(name, offset)
 # 13 bitcount(key, start=None, end=None)
 ---- 比特位---操作-----
 
 # 14、bitop(operation, dest, *keys)
 	获取多个值，并将值做位运算，将最后的结果保存至新的name对应的值
 
 # 15、strlen(name)
 	获取指定key对应值的位数（按字节）
 	res = coon.strlen('name')
 
 # 16、incr(self, name, amount=1)
 	自增（默认自增：1，不支持含有浮点类型）
 	conn.incr('age')
 
 # 17、incrbyfloat(self, name, amount=1.0)
 	自增(支持小数)
 
 # 18、decr(self, name, amount=1)
 	自减
 
 # 19、append(key, value)
 	在指定key对应值的后面添加指定字符
 	conn.append('name','NB')
 </code>

#### **2、2.List类型** ####

<code class="language-python">from redis import Redis
 
 conn = Redis(host='127.0.0.1', port=6379)
 
 # 1、lpush(name, values)
 # 键为key，值为list（参数位置在前生成数据的索引位置就在后）
 conn.lpush('gender', 'male', 'female')
 
 # 2、rpush(name, values)
 # 键为key，值为list（参数位置在前生成数据的索引位置就在前）
 conn.rpush('hobby', 'read', 'run')
 
 # 3、lpushx(name, value)
 # 向列表插入一个值（有对应的key就插入到列表的头部，没有就不操作）
 conn.lpushx('gender', 'female')
 
 # 4、rpushx(name, value)
 # 向列表插入一个值（有对应的key就插入到列表的尾部部，没有就不操作）
 conn.rpushx('hobby', 'ball')
 
 # 5、llen(name)
 # 判断列表内有多少个数据
 print(conn.llen('hobby'))
 
 # 6、linsert(name, where, refvalue, value))
 # name：插入到哪个列表
 # where：插入到指定值的前或后before：前/after：后
 # refavalue：插入到哪个值
 # value：插入的值
 # 向列表内插入数据
 conn.linsert('hobby', 'after', 'run', 'go')
 
 # 7、lset
 # 向指定的索引位置插入一个值
 conn.lset('hobby', 1, 'sleep')
 
 # 8、lrem
 # 删除指定的值，可以指定删除的数量，填 0 全部删除，负数从后面删除
 conn.lrem('hobby', 0, 'aaaa')
 
 # 9、lpop(name)
 # 从头部弹出一个值，可以接收
 res = conn.lpop('hobby')
 print(res)
 
 # 10、rpop(name)
 # 从尾部弹出一个值，可以接收
 res = conn.rpop('hobby')
 print(res)
 
 # 11、lindex(name, index)
 # 按照索引位置取值
 res = conn.lindex('hobby', 1)
 print(res)
 
 # 12、lrange(name, start, end)
 # 按照索引位置，范围取值，第二个参数填负数取全部
 res = conn.lrange('hobby', 0, -1)
 print(res)
 
 # 13、ltrim(name, start, end)
 # 修剪，留下索引位置内的数据
 res = conn.ltrim('hobby', 1, 2)
 print()
 
 # 14、rpoplpush(src, dst)
 # 提供两个列表，将第一个列表的值被弹出，加入到第二个列表内
 conn.lpush('gender', 'male')
 conn.rpoplpush('gender', 'hobby')
 
 # 15、blpop(keys, timeout)
 # 可做消息队列，弹出数据（从左向右）
 res = conn.blpop('hobby')
 print(res)
 
 # 16、brpop(keys, timeout)
 # 可做消息队列，弹出数据（从右向左）
 res = conn.brpop('hobby')
 print(res)
 
 # 17、brpoplpush(src, dst, timeout=0)
 # 将弹出的数据加入到两一个列表中
 res = conn.brpoplpush('hobby','gender')
 print(res)
 
 conn.close()
 </code>

#### **2、3.Hash类型** ####

<code class="language-python">import redis
 
 conn = redis.Redis()
 
 # 1、hset(name, key, value)
 # 设置一个key，value值为字典
 conn.hset('userinfo','name','lqz')
 # 这种方法可以一次写入多个键值对
 conn.hset('userinfo',mapping={'age':19,'hobby':'篮球'})
 
 # 2、hmset(name, mapping)
 # 批量设置，被弃用了，以后都使用hset
 conn.hmset('userinfo2',{'age':19,'hobby':'篮球'})
 
 # 3、hget(name,key)
 # 取值
 res = conn.hget('userinfo', 'name')
 print(res)
 
 # 4、hmget(name, keys, *args)
 # 批量取值
 res = conn.hmget('userinfo', ['name', 'age'])
 # 第二种写法
 res = conn.hmget('userinfo', 'name', 'age')
 print(res)
 
 # 5、hgetall(name)
 # 一次性取出所有的值（慎用，数据量庞大的话会引起司机、宕机）
 res=conn.hgetall('userinfo')
 print(res)
 
 # 6、hlen(name)
 # 获取键值对的数量
 res=conn.hlen('userinfo')
 print(res)
 
 # 7、hkeys(name)
 # 一次性获取所有key值
 res=conn.hkeys('userinfo')
 print(res)
 
 # 8、hvals(name)
 # 一次性获取所有value值
 res=conn.hvals('userinfo')
 print(res)
 
 # 9、hexists(name, key)
 # 判断value值是否存在，返回1/0
 res = conn.hexists('userinfo', 'name')
 res = conn.hexists('userinfo', 'name1')
 print(res)
 
 # 10、hdel(name,*keys)
 # 删除对应的value值
 res = conn.hdel('userinfo', 'age')
 print(res)
 
 # 11、hincrby(name, key, amount=1)
 # 指定字段自增，默认自增1
 conn.hincrby('userinfo', 'age', 2)
 
 
 # 12、hincrbyfloat(name, key, amount=1.0)
 # 自增，支持小数
 
 # 13、hgetall(name)
 # 一次性取出所有value的键值对
 # 插入一批数据
 for i in range(1000):
 conn.hset('hash_test','id_%s'%i,'鸡蛋_%s号'%i)
 res=conn.hgetall('hash_test') # 可以，但是不好，一次性拿出，可能占很大内存
 print(res)
 
 
 # 14、hscan(name, cursor=0, match=None, count=None) 
 # 按照游标位置取值
 res = conn.hscan('hash_test', cursor=0, count=5)
 print(len(res[1])) #（数字，拿出来的10条数据） 数字是下一个游标位置
 
 
 
 # 15、hscan_iter(name, match=None, count=None)
 # 类似生成器，一次只拿出指定数量的值
 res = conn.hscan_iter('hash_test', count=10)
 print(res) # generator 只要函数中有yield关键字，这个函数执行的结果就是生成器 ，生成器就是迭代器，可以被for循环
 for i in res:
 print(i)
 
 conn.close()
 
 </code>

#### **4、通用操作** ####

### **3、Redis管道** ###

**什么是管道：**

管道是指，将多条redis操作放在***管道内***同时执行，管道也是一种**事务**的操作，可以作用于敏感，重要的数据

**ridis支持事务吗：**

redis的事务基于管道，只有单实例才支持事务

**ridis管道的使用：**

<code class="language-python"># 引入redis
 import redis
 
 # 实例化redis对象
 conn = redis.Redis()
 
 # 实例化管道
 p = conn.pipeline(transaction=True)
 
 # 开启管道(类似于开启事务)
 p.multi()
 # 模拟张三给李四100元
 p.decr('zhangsan', 100)
 # 模拟李四账户增加100元
 p.incr('lisi', 100)
 # 启动管道（类似于提交事务）
 p.execute()
 
 # 关闭
 p.close()
 </code>

## **三、Django操作Redis** ##

### **1、自定义包方案** ###

**这种方案所有的框架都可以使用**

<code class="language-python">- 1、第一步：创建一个pool.py文件（导入rides，并实例化对象，生成连接池）
 	import Redis
 	# 实例化对象，设置连接池最大数量为100
 	POOL = Redis.CoonectionPool(max_connections=100)
 
 - 2、第二步：在以后需要使用的地方直接导入使用即可
 from pool import POOL 
 from redis import Redis
 conn = Redis(connections=POOL)
 conn.set('name','kangkang')
 res = conn.get('name')
 </code>

### **2、将Redis设置为Django缓存\[推荐使用\]** ###

**需要安装模块，配置settings文件，以后直接作为Django内置缓存使用**

<code class="language-python">- 安装模块：
 	pip install django-redis
 
 - settings.py 中配置：
 CACHES = {
 "default": {
 "BACKEND": "django_redis.cache.RedisCache",
 "LOCATION": "redis://127.0.0.1:6379", # 地址和端口
 "OPTIONS": {
 "CLIENT_CLASS": "django_redis.client.DefaultClient",
 "CONNECTION_POOL_KWARGS": {"max_connections": 100} # 连接池
 # "PASSWORD": "123", # 密码，没有的话不用设置
 }
 }
 }
 
 
 - 在需要使用的地方直接使用即可（但是只能支持内存的操作）
 from django.core.cache import cache
 在使用redis的地方：cache.set('count', res+1) # 可以存入任何类型的数据
 # 底层做了pickle序列化 
 </code>

### **3、使用第三方模块** ###

**直接使用django-redis模块**

<code class="language-python">
 from django_redis import get_redis_connection
 
 def test_redis(request):
 conn=get_redis_connection()
 print(conn.get('count'))
 return JsonResponse()</code>

[-2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/6c6a82700185418daffe7269f72764ef.png
[Releases _ microsoftarchive_redis _ GitHub]: https://github.com/microsoftarchive/redis/releases
[Releases _ tporadowski_redis _ GitHub]: https://github.com/tporadowski/redis/releases/
[42fbd1cdb715685b27e53d0313bf6017.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/25e52e3ca3da4e6b89b74f8dea45afd7.png
[c909130709008a1be1a325c1ded88a6e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/7e12edc180f84b51b9aab1add9828286.png