Redis数据库快速入门

一、Redis数据库

介绍:

Redis:非关系型缓存数据库

  • nosql:非关系型数据库

    • 没有表,没有表与表之间的关系,更不存在外键
    • 存储数据的形式为key:values的形式
    • c语言写的服务(监听端口),用来存储数据的,数据是存储在内存中,取值,放值速度非常快, 10w qps
  • 缓存数据库:

    • 数据存储在内存中
    • 大部分时间用于缓存,也可以长久存储数据
  • redis速度为什么这么快:

    • 纯内存操作
    • 网路模型使用的IO多路复用(可以处理的请求更多)
    • 6.x版本之前,单进程,单线程,不存在进程线程之间切换,更少消耗资源

字符串类型使用-2.png

1、redis的安装与运行

版本选择:

安装:
Redis缓存数据库-快速入门
Redis缓存数据库-快速入门
Redis缓存数据库-快速入门
Redis缓存数据库-快速入门

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图形化操作文件

可以使用软件:

Redis Desktop Manager :开源的,原来免费,后来收费了  推荐用(mac,win,linux 都有)

-Qt5  qt是个平台,专门用来做图形化界面的 
    -可以使用c++写
    -可以使用python写  pyqt5  使用python写图形化界面 (少量公司再用)
    
-resp-2022.1.0.0.exe 一路下一步,安装完启动起来

-Redis Client  小众

RESP操作redis:

Redis缓存数据库-快速入门

二、pycharm操作redis

安装模块:

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

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

1、Redis普通连接和连接池

普通链接:

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

# 导入模块
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()

连接池连接:

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

POOL.py

# 1、使用单例模式(保证每次使用的都是同一个实例对象),设置连接池最大为10个
    import redis

    POOL = redis.ConnectionPool(
        # 最大链接
        max_connections=10,
        # 指定服务端地址
        host='127.0.0.1',
        prot=6379
    )

my_redis.py

# 导入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()

2、Redis数据类型

介绍:

redis 是key-value形式存储

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

类型 介绍
字符串(string) 用的最多,做缓存;做计数器
列表(list) 常用于消息队列
字典(hash) 缓存
集合(set) 去重
有序集合(zset) 排行榜

2、1.String类型

# 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')

2、2.List类型

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()

2、3.Hash类型

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()

4、通用操作

import redis

conn = redis.Redis()

# 1、delete(*names)
    # 删除指定的key,一次删除多个
    conn.delete('name', 'userinfo2')
    conn.delete(['name', 'userinfo2'])  # 不能用它
    conn.delete(*['name', 'userinfo2'])  # 可以用它,打散


# 2、exists(name)
    # 判断redis中是否存在指定的key(返回 0/1)
    res=conn.exists('userinfo')
    print(res)


# 3、keys(pattern='*')
    # 查找value的key值中是否存在指定的key,返回对应的value(支持简单的正则)
    res=conn.keys('w?e')  #  ?表示一个字符,   * 表示多个字符
    print(res)


# 4、expire(name ,time)
    # 设置过期时间
    conn.expire('userinfo',3)

# 5、rename(src, dst)
    # 重命名
    conn.rename('hobby','hobby111')

# 6、move(name, db)
    # 更改存储数据的库
    conn.move('hobby111',8)


# 7、randomkey()
    # 随机获得一个key
    res = conn.randomkey()
    print(res)

# 8、type(name)
    # 判断数据的类型
    print(conn.type('userinfo'))
    print(conn.type('age'))

conn.close()

3、Redis管道

什么是管道:

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

ridis支持事务吗:

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

ridis管道的使用:

# 引入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()

三、Django操作Redis

1、自定义包方案

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

- 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')

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

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

- 安装模块:
	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",  # 密码,没有的话不用设置
            }
        }
    }
    

- 在需要使用的地方直接使用即可(但是只能支持内存的操作)
    在使用redis的地方:cache.set('count',  res+1)  # 可以存入任何类型的数据
    # 底层做了pickle序列化 

3、使用第三方模块

直接使用django-redis模块


from django_redis import get_redis_connection

def test_redis(request):
    conn=get_redis_connection()
    print(conn.get('count'))
    return JsonResponse()