034_非关系型数据库Redis_安装配置 & 基础语法 & Python交互

文章目录

• • • 1. 认识Redis
    • 2. Redis 安装和配置
    • 3. Redis 数据类型
    • 4. Redis 内置指令
    • 5. Redis 配置文件——远程登陆
    • 6. Redis 应用场景
    • • 6.1 Redis 应用——手机手机验证码
      • 6.2 Redis 应用——基于IP限制HTTP访问频率
      • 6.3 Redis 应用——自行设计列表实现消息队列
    • 7. Redis 持久化存储
    • 8. Redis 架构
    • 9. Python 与 Redis
    • • 9.1 实例化对象方式
      • 9.2 管道 pipline 优化程序

1. 认识Redis

Redis(Remote Dictionary Server, 远程字典数据服务)，是一款内存高速缓存数据库。使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API的非关系型(NoSQL)数据库。
NoSQL(Not Only SQL )，意为“不仅仅是SQL”，泛指非关系型的数据库。NoSQL数据库的产生是为解决大规模数据集和多重数据种类带来的挑战，尤其是大数据应用难题，包括超大规模数据的存储。

理解什么是内存高速缓存数据库

• 对于数据加载速度而言，是硬盘 < 内存 < Cache的
• 缓存有两种类型：1). 页面缓存，经常会用在CMS(content management system)里面；2). 数据缓存，经常会用在页面的具体数据里面。

某商城的页面是适合做数据缓存的，即数据在短时间内不会发生变化，且频繁被访问， 为提高用户的请求速度和降低网站的负载， 将数据放到一个读取速度更快的介质上，称为数据缓存。该介质可以是文件、数据库、内存。内存经常用于数据缓存。

Redis 和 Memcache 的区别(Redis的优点)：

对比	Redis	Memcache
流行度	流行	下滑
网络IO模型	单核	多核
数据类型	支持多种数据类型	仅支持简单的键值对
数据持久化	支持	不支持
主从模式	支持	不支持
单个Value值最大限制	1GB	1MB
删除机制	惰性删除+定期删除	惰性删除

2. Redis 安装和配置

开发环境：redhat + Redis

step1. 首先上官网下载Redis 压缩包，地址 http://redis.io/download
step2. 压缩包执行解压操作

su -
cd /opt/  # 一般的安装第三方软件的路径
tar xzf redis-5.0.5.tar.gz  # 注意将redis-5.0.5.tar.gz放置在路径 /opt/ 下，并注意压缩包的版本号
cd redis-5.0.5/

step3. 进行编译

方法一：

make

方法二：

sh utils/install_server.sh

step4. 运行，开启Redis服务器

redis-server &

查看一下确实是开启的

>> ps -A | grep redis
 17028 ?        00:00:02 redis-server

step5. 运行，登陆Redis服务端，默认端口为6379，无密码

redis-cli

测试一下：

>> redis-cli
127.0.0.1:6379> ping
PONG
127.0.0.1:6379> set name xiaohua
OK
127.0.0.1:6379> get name
"xiaohua"
127.0.0.1:6379> 

3. Redis 数据类型

• string 类型：是二进制安全的。可以包含任何数据(eg: jpg 图片或者序列化的对象)。从内部实现来看其实 string 可以看作 byte 数组，最大上限是 1G 字节。
• hash 类型：是一个 string 类型的 field 和 value 的映射表。它的添加、删除操作都是 O(1)（平均）。
• list类型：是一个 string 类型的双向链表。最大长度是(232 )。
• set 类型：是 string 类型的通过 hash table 实现的无序集合。添加、删除和查找的复杂度都是 O(1)。最大长度是(232 )。

4. Redis 内置指令

全面的 Redis 内置指令可参考：Redis | 菜鸟教程https://www.runoob/redis/redis-commands.html

sting 数据类型的常用指令示例：

127.0.0.1:6379> set name xiaohua
OK
127.0.0.1:6379> get name
"xiaohua"
127.0.0.1:6379> GETRANGE name 0 3
"xiao"
127.0.0.1:6379> SETRANGE name 4 hong
(integer) 8
127.0.0.1:6379> get name
"xiaohong"
127.0.0.1:6379> SET age 100
OK
127.0.0.1:6379> MGET name age
1) "xiaohong"
2) "100"
127.0.0.1:6379> STRLEN name
(integer) 8
127.0.0.1:6379> INCR age
(integer) 101
127.0.0.1:6379> get age
"101"
127.0.0.1:6379> INCRBY age 10
(integer) 111
127.0.0.1:6379> get age
"111"
127.0.0.1:6379> DECR age
(integer) 110
127.0.0.1:6379> DECRBY age 10
(integer) 100
127.0.0.1:6379> get age
"100"
127.0.0.1:6379> APPEND name -haha
(integer) 13
127.0.0.1:6379> get name
"xiaohong-haha"
127.0.0.1:6379> BITCOUNT name
(integer) 52
127.0.0.1:6379> GETSET name xiaohua
"xiaohong-haha"
127.0.0.1:6379> GETSET name1 xiaohua
(nil)
127.0.0.1:6379> get name1
"xiaohua"
127.0.0.1:6379> 

list 数据类型的常用指令：

127.0.0.1:6379> LPUSH names xiaobai xiaolan xiaohuang
(integer) 3
127.0.0.1:6379> LRANGE names 0 2
1) "xiaohuang"
2) "xiaolan"
3) "xiaobai"
127.0.0.1:6379> RPUSH names xiaoxiao
(integer) 4
127.0.0.1:6379> LRANGE names 0 3
1) "xiaohuang"
2) "xiaolan"
3) "xiaobai"
4) "xiaoxiao"
127.0.0.1:6379> LPOP names
"xiaohuang"
127.0.0.1:6379> RPOP names
"xiaoxiao"
127.0.0.1:6379> GET names
(error) WRONGTYPE Operation against a key holding the wrong kind of value
127.0.0.1:6379> LRANGE names 0 1
1) "xiaolan"
2) "xiaobai"
127.0.0.1:6379> LRANGE names 0 2
1) "xiaolan"
2) "xiaobai"
127.0.0.1:6379> RPOP names
"xiaobai"
127.0.0.1:6379> RPOP names
"xiaolan"
127.0.0.1:6379> BLPOP names 2
(nil)
(2.08s)

等等等…

5. Redis 配置文件——远程登陆

1. 打开 Redis 的配置文件 一般是 /etc/redis/xxx.conf

vim /etc/redis/redis.conf

2. 对配置文件进行修改

# 允许所有ip进行绑定
bind 0.0.0.0
# 关闭保护模式 将 yes 修改为 no
protected-mode no

3. Redis 服务器重新加载配置文件

redis-server /etc/redis/redis.conf

6. Redis 应用场景

Redis 能做什么：

• 缓存
• 排行榜 (集合)
• 计数器/限速器 (统计播放数据、浏览量、在线人数等)
• 好友关系 (点赞/共同好友 (交并集))
• 简单消息队列 (订阅发布/阻塞队列)
• session 服务器 (存储用户session 信息)

Redis 不能做什么：

• 数据量太大不适合
• 数据访问频率太低不适合

6.1 Redis 应用——手机手机验证码

"""
限制某段时间内的访问次数，就比如我们登录的功能可以用手机获取验证码登录，但是我们发送验证码使用的第三方，是多少钱多少条的，
肯定不能让他一直点，一直发短信，就算前端js做了校验，若有些人用fiddler拦截绕过前台就麻烦了，
这时候可以用 redis 的 incr 命令和 expire 结合起来做一个解决方案

1. 用户请求了我们的发送短信验证码服务, 用户对应的key（电话号码）
2. 如果缓存中存在了，就是已经请求过验证码了，比如我系统参数设置的至少60秒发送一次短信, 那就代表60之内再次请求了，返回False阻止
3. 否则就是第一次请求短信验证码或者等了60再次请求的验证码, 发送验证码. 放入redis缓存并设置失效时间60秒

"""
import time


def send_msg(phone):
    """模拟给手机发送验证码"""
    import string
    import random
    # 返回一个列表：['4', '1', '5', '9']
    nums_list = random.sample(string.digits, 4)
    nums_code = "".join(nums_list)
    print("%s验证码：%s" %(phone, nums_code))
    return  nums_code

def phone_code(phone):
    """
    电话验证码模拟, 3秒之后可以再次发送验证码
    :param phone:
    :return:
    """
    import redis
    # 实例化 redis 客户端对象，默认：host='localhost', port=6379, password=None...
    client = redis.StrictRedis()
    # 可以从缓存中查询验证码已经发送。
    if client.get(phone):
        print("验证码发送频繁， 请稍后再试")
        return  False
    else:
        code = send_msg(phone)
        # phone:code 3秒之后过期 --> 实现 3 秒之后可以再次发送验证码 
        client.set(phone, code, 3)
        print("发送验证码成功")


if __name__ == '__main__':
    print("第一次发送")
    phone_code('110')
    print("第二次发送")
    phone_code('110')
    time.sleep(4)
    print("第三次发送")
    phone_code('110')

6.2 Redis 应用——基于IP限制HTTP访问频率

"""
IP限制频繁访问:
    如果你运行 HTTP 服务，并且希望限制 HTTP 的访问频率，那么你可以借助一些比较稳定的工具，
    例如： github/didip/tollbooth。不过如果你构建的应用比较简单，也可以自己来实现。
IP限制的规则:
    每分钟访问次数不能超过60次。
"""

def ip_limit(IP):
    """
    每分钟访问次数不能超过60次。
    key: value = IP:count
    :param IP:
    :return:
    """
    import redis
    # 实例化 redis 客户端对象，默认：host='localhost', port=6379, password=None...
    client = redis.StrictRedis()
    # 判断是否访问过本服务器
    if client.exists(IP):
        count = client.get(IP).decode('utf-8')
        if int(count) >= 60:
            print("%s访问频繁" %(IP))
        else:
            client.incr(IP)
            print("访问+1")
    else:
        client.set(IP, 1, 60)
        print("%s第一次访问" %(IP))


if __name__ == '__main__':
    for i in range(100):
        ip_limit('127.0.0.1')

6.3 Redis 应用——自行设计列表实现消息队列

"""
Redis: 内存缓存数据库， 消息队列(kafka、RabbitMQ)
# 如何实现高并发场景下抢红包的设计。(思想！相关拓展)
"""
import  queue

class RedisQueue(object):
    """左边为队头， 右边为队尾的消息队列"""
    def __init__(self, name, **conf):
        import redis
        # 实例化 redis 客户端对象
        self.__client = redis.Redis(**conf)
        self.key = name

    def qsize(self):
        return  self.__client.llen(self.key)

    def put(self, item):
        """入队操作"""
        self.__client.rpush(self.key, item)

    def get(self, timeout=5):
        """获取对头， 如果没有到， 等待时间为timeout"""
        item = self.__client.blpop(self.key, timeout=timeout)
        return  item

    def get_nowait(self):
        item = self.__client.blpop(self.key)
        return  item

if __name__ == '__main__':
    q = RedisQueue('scores', host='127.0.0.1', port=6379)
    for i in range(10):
        q.put(i)

    while True:
        result = q.get(timeout=3)
        '''
        result=
        (b'scores', b'0')
		(b'scores', b'1')...
		'''
        print(result)
        if not result:
            break

7. Redis 持久化存储

Redis 是一个内存数据库，与传统的MySQL，Oracle等关系型数据库直接将内容保存到硬盘中相比，内存数据库的读写效率比传统数据库要快的多(内存的读写效率远远大于硬盘的读写效率)。但是数据保存在内存中也随之带来了一个缺点，一旦断电或者宕机，那么内存数据库中的数据将会全部丢失。
于是，持久化就是把内存的数据写到磁盘中去，防止服务宕机了内存数据丢失。
Redis 提供了两种持久化方式：RDB(默认)和AOF

1. RDB，是 Redis 用来进行持久化的一种方式，是把当前内存中的数据集快照写入磁盘，也就是 Snapshot 快照(数据库中所有键值对数据)。恢复时是将快照文件直接读到内存里
2. AOF，对指令进行备份，当 Redis 重启时会通过重新执行文件中保存的写命令在内存中重建整个数据库中的内容。对于RDB 持久化存，是一定时间内做一次备份，如果 Redis 意外down掉的话，就会丢失最后一次快照后的所有修改(数据有丢失)。

8. Redis 架构

1. 单机版，特点：简单；问题：内存容量有限 、处理能力有限 、无法高可用。
2. 主从复制：Redis 的复制(replication)功能允许用户根据一个 Redis 服务器来创建任意多个该服务器的复制品，其中被复制的服务器为主服务器(master)，而通过复制创建出来的服务器复制品则为从服务器(slave)。 只要主从服务器之间的网络连接正常，主从服务器两者会具有相同的数据，主服务器就会一直将发生在自己身上的数据更新同步给从服务器，从而一直保证主从服务器的数据相同。
   特点：master/slave 角色、master/slave 数据相同、降低 master 读压力再转交从库
   问题：无法保证高可用、没有解决 master 写的压力

9. Python 与 Redis

9.1 实例化对象方式

实例化 Redis 对象的方式正如 Redis 应用中的代码示例，–> 问题：每对数据库的执行一次读写操作时，都需要建立 TCP 连接，严重影响性能

9.2 管道 pipline 优化程序

pipline：缓存多条命令，一次性执行，减少服务端与客户端间 TCP 数据包，提高效率
代码示例：

import redis

redis_client = redis.StrictRedis()
# 创建管道pipline 对象即可
pipe = redis_client.pipeline()
pipe.set('name', '小红')
pipe.set('name', '小美')
pipe.set('name', '小白')
pipe.set('name', '小明')
pipe.set('name', '小兰')
# 缓存多条命令，一次性执行
pipe.execute()