路飞项目----day10（redis之列表的操作方法，redis之hash的操作方法，redis的其他操作方法，redis管道的操作方法，django中使用redis，celery介绍和安装，celery包结构的使用）

昨日回顾

# 1 登录注册前端
	-登录
    	-手机验证码登录---》输入框输入手机号---》监听失去焦点事件---》手机号正则校验(js),查询手机号是否存在----》发送验证码的按钮可以点击---》点击发送验证码按钮---》ajax 发送验证码---》起了个定时任务---》手机收到了验证码，填入验证码框-----》点击登录按钮----》向后端发送登录ajax请求----》返回给前端token和username----》前端保存到cookie中----》子传父，关闭了登录模态框----》在Header.vue 取了一下token和username
        -多方式登录---》输入用户名和密码后----》点击登录--》后端登录成功，返回username和token---》后面的同上
        
    -注册
    	-输入手机号---》监听失去焦点事件---》手机号正则校验(js),查询手机号是否存在-如果不存在---》发送验证码的按钮可以点击---》点击发送验证码按钮---》ajax 发送验证码---》起了个定时任务---》手机收到了验证码，填入验证码框-----》填入密码---》点击注册---》调用注册接口完成注册----》子传父---》Register.vue---->显示出Login.vue


# 2 redis 介绍
	-数据库，非关系型数据库，缓存数据库，key-value形式存储，数据都在内存中，有5大数据类型，速度非常快，数据操作是单线程，不存在并发安全的问题
    	-redis的缓存更新策略 
    -为什么这么快：
    	1 纯内存操作
        2 高性能的网络模型 IO多路复用(epoll)
        3 单线程，不存在线程间切换
        
    -redis版本
    	7.x    最新
        6.x    从它后，多进程，多线程架构
        5.x及之前  单进程单线程架构
        
    -进程：资源分配的最小单位，一个程序运行起来，可能一个进程，也可能多个进程
    -线程：cpu调度的最小单位，遇到io操作，操作系统层面切换
    -协程：单线程下的并发，程序层面控制，遇到io操作，切换到别的任务执行



# 3 安装redis
	-mac    编译完成了，bin路径下  redis-server redis-cli
    -linux  编译安装 
    -win    专门的安装包
       一路下一步
        
        
     -安装完成会有两个命令：启动服务端，启动客户端   cs架构的软件
     -客户端和服务端在同一台机器上
     -本地的客户端可以连接远程的服务器
     -mysql 也是cs架构软件
        -pymysql ：是mysql的客户端
        -Navicate：是mysql客户端
        -go语言操作mysql：是mysql客户端
        
     -启动redis服务
    	-redis-server 指定配置文件
        -使用服务启动
     -客户端连接
    	-cmd中使用redis-cli
        -图形化界面
        -python的redis模块操作redis


# 4 python连接redis
	-普通连接
    -连接池连接:单例模式
	-django 使用mysql连接池


# 5 redis 5大数据类型之字符串  value值是字符串
    -get
    -set
    -strlen
    -mset
    -mget
    -getrang
    ....

.
.
.
.
.

今日内容

1 redis之列表的操作方法

'''
1 lpush(name, values)
2 rpush(name, values) 表示从右向左操作
3 lpushx(name, value)
4 rpushx(name, value) 表示从右向左操作
5 llen(name)
6 linsert(name, where, refvalue, value))
7 r.lset(name, index, value)
8 r.lrem(name, value, num)
9 lpop(name)
10 rpop(name) 表示从右向左操作
11 lindex(name, index)
12 lrange(name, start, end)
13 ltrim(name, start, end)
14 rpoplpush(src, dst)
15 blpop(keys, timeout)
16 r.brpop(keys, timeout)，从右向左获取数据
17 brpoplpush(src, dst, timeout=0)

'''

import redis

conn = redis.Redis()
# 1 lpush(name, values)   从左侧插入
# conn.lpush('girls', '刘亦菲', '迪丽')


# 2 rpush(name, values)   从右向左操作
# conn.rpush('girls', '小红')


# 3 lpushx(name, value)   键有才能从左侧插入数据
# conn.lpushx('boys','小刚')   # boys键没有所以，无法插入
# conn.lpushx('girls','小刚')  # girls键有，所以可以插入


# 4 rpushx(name, value)  键有才能从右侧插入数据


# 5 llen(name)   列表里面数据个数
# res = conn.llen('girls')
# print(res)


# 6 linsert(name, where, refvalue, value))   以指定的值为参照物，插在该值的前面或后面
# conn.linsert('girls','before','迪丽','娜扎')  # 在迪丽前插入一个娜扎
# conn.linsert('girls', 'after', '小红', '小绿')
# conn.linsert('girls', 'after', '小黑', '小嘿嘿')  # 没有参照物，插入不进去


# 7 r.lset(name, index, value)  # 按位置改值
# conn.lset('girls',1,'xxx')


# 8 r.lrem(name, value, num)    # 删除值，可以指定删除值的个数
# conn.lrem('girls', 1, '刘亦菲')  # 从左侧开始，删除1个 xxx
# conn.lrem('girls',-1,'xxx')  # 从右侧开始，删除1个
# conn.lrem('girls',0,'xxx')  # 从左开始，全删除


# 9 lpop(name)    从左侧弹出数据
# res = conn.lpop('girls')
# print(res)

# 10 rpop(name)  从右侧弹出数据


# 11 lindex(name, index)   # 按索引取值
# res = str(conn.lindex('girls', 0), encoding='utf-8')
# print(res)


# 12 lrange(name, start, end)   # 按索引区间拿多个值，也可以拿一个值
# res = conn.lrange('girls', 0, 1)  # 前闭后闭区间
# print(res)


# 13 ltrim(name, start, end)   # 只保留对应索引区间的值
# conn.ltrim('girls', 2, 3)


# 14 rpoplpush(src, dst)  # 两个列表合并用


# 15 blpop(keys, timeout)  # 可以做简单的消息队列使用  阻塞式弹出，如果没有，就阻塞
# res = conn.blpop('girls')  # 从列表左侧弹出一个值
# print(res)

# 16 r.brpop(keys, timeout)， # 从列表右侧弹出一个值


# 17 brpoplpush(src, dst, timeout=0)  # 从一个列表里弹出一个，推到另一个列表里去

conn.close()

'''
需要记住方法：
lpush
lpop
llen
lrange
'''

.
.
.
.
.
.

2 redis之hash的操作方法

'''
1 hset(name, key, value)
2 hmset(name, mapping)
3 hget(name,key)
4 hmget(name, keys, *args)
5 hgetall(name)
6 hlen(name)
7 hkeys(name)
8 hvals(name)
9 hexists(name, key)
10 hdel(name,*keys)
11 hincrby(name, key, amount=1)
12 hincrbyfloat(name, key, amount=1.0)
13 hscan(name, cursor=0, match=None, count=None)
14 hscan_iter(name, match=None, count=None)

'''

import redis

conn = redis.Redis()
# 1 hset(name, 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)
# res=conn.hkeys('userinfo')
# print(res)

# 8 hvals(name)
# res=conn.hvals('userinfo')
# print(res)

# 9 hexists(name, key)
# res = conn.hexists('userinfo', 'name')
# res = conn.hexists('userinfo', 'name1')
# print(res)

# 10 hdel(name,*keys)
# res = conn.hdel('userinfo', 'age')
# print(res)

# 11 hincrby(name, key, amount=1)
conn.hincrby('userinfo', 'age', 2)
# article_count ={
#     '1001':0,
#     '1002':2,
#     '3009':9
# }

# 12 hincrbyfloat(name, key, amount=1.0)

# hgetall  会一次性全取出，效率低，可以能占内存很多
# 分批获取，hash类型是无序
# 插入一批数据
# for i in range(1000):
#     conn.hset('hash_test','id_%s'%i,'鸡蛋_%s号'%i)

# res=conn.hgetall('hash_test')   # 可以，但是不好，一次性拿出，可能占很大内存
# print(res)
# 13 hscan(name, cursor=0, match=None, count=None)   # 它不单独使用，拿的数据，不是特别准备
# res = conn.hscan('hash_test', cursor=0, count=5)
# print(len(res[1])) #（数字，拿出来的10条数据）   数字是下一个游标位置



# 咱们用这个，它内部用了hscan,等同于hgetall 所有数据都拿出来，count的作用是，生成器，每次拿count个个数
# 14 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()

'''
需要记住的方法

hset
hget
hmget
hlen

hdel
hscan_iter  获取所有值，但是省内存 等同于hgetall
'''

.
.
.
.
.
.
.

3 redis的其他操作方法

'''
通用操作，不指定类型，所有类型都支持

1 delete(*names)
2 exists(name)
3 keys(pattern='*')
4 expire(name ,time)
5 rename(src, dst)
6 move(name, db))
7 randomkey()
8 type(name)
'''

import redis

conn = redis.Redis()
# 1 delete(*names)    # 不管什么类型，直接根据name删除对应的数据
# conn.delete('name', 'userinfo2')   # name与userinfo2对应的数据都删除了
# conn.delete(['name', 'userinfo2'])  # 不能用它


# 2 exists(name)    # 不管什么类型，直接判断name对应的数据，是否存在，返回0/1
# res=conn.exists('userinfo')
# print(res)


# 3 keys(pattern='*')   #  把内存中所有数据对应的名字拿出来
# 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()     # 随机弹出一个数据的名字
# res=conn.randomkey()
# print(res)


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

conn.close()

.
.
.
.
.
.
.
.

4 redis管道的操作方法

# 事务---》四大特性：
	-原子性
	-一致性
	-隔离性
	-持久性


# redis支持事务吗   单实例才支持所谓的事务，支持事务是基于管道的
# redis通过管道可以支持事务

-执行命令  一条一条执行
	-张三 金额 -100    conn.decr('zhangsan_je',100)

		断电程序挂了

	-你   金额 100     conn.incr('lisi_je',100)


- 把这两条命令，放到一个管道中，先不执行，执行excute，一次性都执行完成
	conn.decr('zhangsan_je',100)   conn.incr('lisi_je',100)


# 如何使用
import redis

# 模拟转账操作
conn = redis.Redis()

# conn.decr('zhangsan_je', 100)
#
# raise Exception('崩了')
#
# conn.incr('lisi_je', 100)    # zhangsan金额减了100  但是lisi金额没有增加
#
# conn.close()

p = conn.pipeline(transaction=True)  # 开启事务
p.multi()

p.decr('zhangsan_je', 100)

# raise Exception('崩了')  # 这样后程序崩了，zhangsan数据就不会减了

p.incr('lisi_je', 100)

p.execute()
conn.close()

# 通过管道实现redis支持事务

.
.
.
.
.

CPU缓存（Cache Memoney）位于CPU与内存之间的临时存储器，它的容量比内存小但交换速度快。
在CPU中加入缓存是一种高效的解决方案，这样整个内存储器（缓存+内存）就变成了既有缓存的高速度，又有内存的大容量的存储系统了。缓存对CPU的性能影响很大
总的来说，CPU读取数据的顺序是先缓存后内存。
cache 缓存

.
.

5 django中使用redis

##  方式一：自定义包方案（通用的，不针对于框架，所有框架都可以用）

-第一步：写一个pool.py
    import redis
    POOL = redis.ConnectionPool(max_connections=100)

-第二步：以后在使用的地方，直接导入使用即可
    conn = redis.Redis(connection_pool=POOL)
    conn.incr('count')
    res = conn.get('count')


-----------------------------------------------------

## 方式二：django的方案

-方案一：django的缓存使用redis （django中 推荐使用该方案）
# 需要先装django-redis第三方模块

-需要先在settings.py 中配置
# django 默认使用的是内存作为缓存
# django原生不支持使用redis做缓存，需要使用第三方模块 django-redis
# pip install django-redis 下载该模块  并在配置文件中配置

# CACHES = {
#     'default': {
#         'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
#     }
# }
CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",  # django缓存 改成用redis了
        "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中，
class Person:
    name = 'lqz'


def test_redis(request):
    # cache.set('count', 1)  # 一开始要先在redis中先set创建出缓存文件,后续才能正常的取与改对应的数据
    # res = int(cache.get('count'))
    # cache.set('count', res + 1)

    p8 = Person()
    cache.set('person888', p8)  # 先往缓存里面存对象
    res2 = cache.get('person888')   # 再从缓存里面取对象
    print(res2.name)
    return JsonResponse({'count': '该接口今日被访问次数:%s'}, json_dumps_params={'ensure_ascii': False})


# -总结：在使用redis的地方：
cache.set('xx',  yy)    # 用redis作为缓存，往redis中放入yy数据，数据名叫xx
res = cache.get('xx')   # 从redis中取出，数据名叫xx的数据


	往redis里面能存对象的的原因是，存之前，
	底层会自动将对象使用pickle序列化为字符串了，再存入
	注意要存的对象，类要定义在全局。为什么？因为pickle只会在全局找名字
	找不到就报错了，所以要存到缓存里面的对象，它的类要写在全局

--------------------------------------------
--------------------------------------------

-方案二：使用第三方模块：django-redis模块，直接操作redis
# 也是要配置文件先配置好，和上面一样

# 从配置文件中，配置的连接池中拿一个连接
from django_redis import get_redis_connection

        def test_redis(request):
            conn=get_redis_connection()
            print(conn.get('count'))
            return JsonResponse({'count': '今天这个接口被访问的次数为：%s'}, json_dumps_params={'ensure_ascii': False})

# 存和取的时候时候要先确定数据的类型后，才能用对应的方法往redis里面存数据

.
.
.
.
.
.

6 celery介绍和安装

# Celery 是什么
	是一个python的框架：运行起来就是个服务，跟django无关


# 能用来做什么
	1 异步任务
	2 定时任务
	3 延迟任务

------------------------------------------------
# 理解celery的运行原理

"""
1）可以不依赖任何服务器，通过自身命令，启动服务
2）celery服务为为其他项目服务提供异步解决任务需求
注：会有两个服务同时运行，一个是项目服务，一个是celery服务，
项目服务将需要异步处理的任务交给celery服务，celery就会在需要时异步完成项目的需求！


人是一个独立运行的服务 | 医院也是一个独立运行的服务
	正常情况下，人可以完成所有健康情况的动作，不需要医院的参与；
	但当人生病时，就会被医院接收，解决人生病问题
	人不生病时，人与医院独立运行

	所以django想做异步任务的时候，需要借助于celery
	如果django不做异步，彼此独立运行即可，
"""

-----------------------------------------------

# celery架构（Broker，backend 都用redis）

1 任务中间件（message broker），负责将其他服务提交的异步任务，提交至任务队列，放在里面排队
	-需要借助于第三方 redis 或 rabbitmq

2 任务执行单元 worker     负责将任务从任务队列中取出后的执行！！！
	-celery提供的，worker可以并发的运行在多台电脑上，这样处理异步任务的效率就更高了

3 结果存储库 backend     任务执行的结果存储，存到 backend中
	-需要借助于第三方：redis 或 mysql


# Celery本身不提供消息服务，但是可以方便的和第三方提供的消息中间件集成。
# 包括，RabbitMQ, Redis等等


-----------------------------------------------

# celery的使用场景

	异步执行：解决耗时任务
	延迟执行：解决延迟任务
	定时执行：解决周期(周期)任务

-----------------------------------------------

# celery 不支持win，通过eventlet支持在win上运行
	所以在windows上面要用celery还要再下一个eventlet模块
	pip install celery
	win：pip install eventlet

.
.
.
.
.

7 celery快速使用

# 安装-----安装完成，会有一个可执行文件 celery.exe
	pip install celery
	win：pip install eventlet

---------------------------------------------

# 快速使用

### 第一步：新建 main.py   类实例化生产对象，并管理任务

from celery import Celery

# 提交的异步任务，放在redis的1数据库里面
broker = 'redis://127.0.0.1:6379/2'

# 执行完的结果，放在redis的2数据库里面
backend = 'redis://127.0.0.1:6379/3'

app = Celery('test', broker=broker, backend=backend)
# 第一个参数作用，就是给起个名字而已


@app.task
def add(a, b):
    import time
    time.sleep(3)
    print('---------------------')
    return a + b

# 要对任务用装饰器装饰一下！！！
---------------------------------------------
---------------------------------------------

### 第二步：新建一个py文件，右键运行，提交任务
from main import add

# 提交任务到了broker任务中间件中，但不会运行任务，
# 真正干活的是worker
res = add.delay(5,6)   #原来add的参数，直接放在delay中传入即可

print(res.id)  # f150d8a5-c955-478d-9343-f3b60d0d5bdb

# 右键运行该py文件，只会提交任务，不会运行任务，会返回一个对象
# 对象再点id 可拿任务的id号

---------------------------------------------
---------------------------------------------

### 第三步：启动worker后, worker就会去运行提交到broker里面的任务
必须要先切换到 main.py所在的目录下 不然命令里找不到main文件了！！！

# 启动worker命令，windows需要先安装eventlet
	windows执行命令:
	celery 4.x之前版本  celery worker -A main -l info -P eventlet
	celery 4.x之后版本  celery  -A main  worker -l info -P eventlet

# 该命令的执行，要先cd切换到main.py所在的目录下
# celery就是代表的虚拟环境的scripts里面的celery.exe启动文件
# worker是启动worker
# -A main   是指定执行的文件是 main
# -l info   是指定日志输出的级别

	mac： celery  -A main  worker -l info


# 启动worker之后，worker就会去运行提交到broker里面的任务

---------------------------------------------
---------------------------------------------

### 第四步：worker会执行消息中间件中的任务，把结果存起来

---------------------------------------------
### 第五步：咱们要看执行结果，拿到执行的结果

# 这一步和celery没有关系
from main import app  # 导Celery类生成的对象

from celery.result import AsyncResult
# 导celery源文件里面result.py文件里面的AsyncResult类

id = '51611be7-4914-4bd2-992d-749008e9c1a6'

# app就是mian.py文件里面  Celery类创建的对象
# id 就是提交任务后，返回的任务的id

if __name__ == '__main__':
    a = AsyncResult(id=id, app=app)  # 生成backend库里面的数据对象
    if a.successful():  # 如果结果是true 说明执行完了
        result = a.get()  # 数据对象点get拿到任务函数的返回结果
        print(result)
    elif a.failed():
        print('任务失败')
    elif a.status == 'PENDING':
        print('任务等待中被执行')
    elif a.status == 'RETRY':
        print('任务异常后正在重试')
    elif a.status == 'STARTED':
        print('任务已经开始被执行')

# 就是根据Celery类创建的对象，与任务的id当前所处的状态
# 判断任务在worker里面所处的状态

-----------------------------

# 总结

  第二步与第五步 提交任务与查看任务所处的状态  与celery没有必然联系
  第二步与第五步  一般是要在django中要做的事情

-----------------------------

.
.
.
.
.
.
.
.

8 celery包结构的使用

# 想写一个celery的包，以后在任意程序中导入该包，就可以使用该文件

----------------------------------

项目目录下
    ├── celery_task  	# celery包
    │   ├── __init__.py # 包文件
    │   ├── celery.py   # celery连接和配置相关文件，且名字必须交celery.py
    │   └── tasks.py    # 放所有任务函数
    ├── add_task.py  	# 添加任务或者说提交任务到worker
    └── get_result.py   # 获取结果

--------------------------------------------------

### 第一步：新建包 celery_task
# 在包下新建一个[必须叫celery]的py文件，celery.py 里面写代码

from celery import Celery

# 提交的异步任务，放在里面
broker = 'redis://127.0.0.1:6379/1'

# 执行完的结果，放在这里
backend = 'redis://127.0.0.1:6379/2'

app = Celery('test', broker=broker, backend=backend, include=['celery_task.user_task', 'celery_task.order_task'])
# include里面写好要管理的任务的文件名
# 任务很多，就不放在该文件下了


--------------------------------------------------

### 第二步：在包内部，先定义异步任务

# order_task.py
from .celery import app
import time
@app.task
def add(a, b):
    print('-----', a + b)
    time.sleep(2)
    return a + b


# user_task.py
from .celery import app
import time
@app.task
def send_sms(phone, code):
    print("给%s发送短信成功，验证码为：%s" % (phone, code))
    time.sleep(2)
    return True

--------------------------------------------------

### 第三步：启动worker,注意执行worker的命令，一定要在包所在的目录下执行！！
           原来没用包结构是在main.py文件,所在的目录下执行的
	celery  -A celery_task  worker -l info -P eventlet

--------------------------------------------------

### 第四步：在其他程序中 提交异步任务， 任务被被提交到中间件中，等待worker执行，
### 因为worker启动了，任务就会被worker执行

from celery_task import send_sms
res=send_sms.delay('1999999', 8888)
print(res.id)  # 7d39033c-4cc7-4af2-8d78-e62c277db183

--------------------------------------------------

### 第五步：worker执行完，结果存到backend中

--------------------------------------------------

### 第六步：在其他程序中，可以查看任务的执行结果

from celery_task import app
from celery.result import AsyncResult
id = '7d39033c-4cc7-4af2-8d78-e62c277db183'
if __name__ == '__main__':
    a = AsyncResult(id=id, app=app)
    if a.successful():  # 执行完了
        result = a.get()  #
        print(result)
    elif a.failed():
        print('任务失败')
    elif a.status == 'PENDING':
        print('任务等待中被执行')
    elif a.status == 'RETRY':
        print('任务异常后正在重试')
    elif a.status == 'STARTED':
        print('任务已经开始被执行')

.
.
.
.
.
.

作业

1 redis 列表，hash，其他，管道，django中继承 代码都写一遍


---------------高级-----------------

2 安装celery  使用celery的包结构
	-写一个run.py
    循环打印
        1 异步计算add
        2 发送短信
        3 查看短信发送结果
        4 查看add异步的结果
    用户选了发送短信 ，输入手机号，就可以异步给这个手机号发送短信
    短信已发送