多人博客项目（Django模板+DTL语法+注册接口设计和实现）

1、模板

　　如果使用react实现前端页面，其实Django 就没有必须使用模板（前后端分离），它其实就是一个后台服务程序，接受请求，响应数据，接口设计就可以是纯粹的Restful 风格。

　　模板的目的就是为了可视化，将数据按照一定布局格式输出，而不是为了数据处理，多以一般不会有复杂的处理逻辑，模板的引入实现了业务逻辑和显示格式的分离，这样，在开发中，就可以分工协作，页面开发完成页面布局设计，后台开发王城数据处理逻辑的实现。

　　Python的模板引擎默认使用Django template Language（DTL）构建。

2、模板配置

　　在settings.py中 ， 设置模板项目的路径

　　

 　　DIRS 列表，定义模板文件的搜索路径顺序。

　　APP_DIRS 是否运行在每个已经安装的应用中查找模板，应用自己目录下有temolates目录，例如：

　　django/contrib/admin/temolates. 如果应用需要可分离，可重用，建议吧模板放到应用目录下BASE_DIR

　　是项目根目录，os.path.join（BASE_DIR, 'templates'）就是在manage.py 这一层建立一个目录templates，这个路径就是以后默认找模板的地方。

3、模板渲染

　　模板页：测试，所以自己写一个，并放到根目录下的 templates

　　　　

　　　　但是这样，前后端在一起 开发

　　模板处理：

　　　　2个步骤：

　　　　　　1、加载模板

　　　　　　　　模板是一个文件，需要从磁盘读取并加载，需要将模板放置templeates

　　　　　　2、渲染

　　　　　　　　模板需要使用内容数据来渲染，生成HTML 文件内容

　　　　测试：模板不需要做任何插入数据，只是显示

　　　　

　　　　测试：对模板进行挖空，后台执行时，插入数据

　　　　

　　　　测试：使用短格式，即简单方式；

　　　　

　　　　render的源代码：

　　　　　　

　　　　render_to_string（）是核心方法，其实就是拿数据替换HTML中的指定位置后返回一个字符串

 4、DTL 语法　　

• 变量
• 标签
• 注释
• 过滤器

　　1、变量

　　　　语法：{{  variable }}

　　　　变量名由字母、数字、下划线、点号组成

　　　　点号使用的时候，例如foo.bar，遵循以下顺序：

1. 1. 字典查找，例如foo[" bar" ]，把foo当作字典，bar 当作key
   2. 属性或方法的查找，例如 foo.bar ,把foo当作对象，bar 当作属性或方法
   3. 数字索引查找，例如 foo[bar] 把foo当作列表一样，使用索引访问　　

　　　　　　测试：

　　　　　　

　　　　　　测试：2

　　　　　　

　　　　　　如果变量未能找到，则缺省插入空字符串

　　　　　　在模板中调用方法，不能加小括号，自然也就不能传递参数。　　　　　

　　　　　　{{dict.keys}}<br />

　　2、标签

　　　　if/ else 标签

　　　　基本语法格式如下：有开始，就有关闭 endif

　　　　　　     或者       

　　　　条件也支持 and， or， not

　　　　注意：因为这些标签是断开的，所以不能像python那样使用缩进就可以表示出来，必须有结束标签，例如：endif， endfor

　　　　for 标签：https://docs.djangoproject.com/en/2.0/ref/templates/builtins/#for

　　　　　　

　　　　　　

　　　　　　

　　　　　　给标签增加一个reversed 使得该列表别反向迭代。

　　　　　　　　

　　　　　　可以嵌套使用{% for %}标签

　　　　　　　　

　　　ifequal ， ifnotequal 标签　　　　　

　　　　　{% ifequal %} 标签比较两个值，当他们相等时，显示在{% ifequal%} 和 {% endifequal %} 之中所有的值　　　　　　　　　　　

 　　　　　

　　　　和 if 类似， 也支持可选的 else 标签

　　　　　　

　　　其他标签

　　　　　csrf_token 用于跨站请求伪造保护，防止跨站攻击

　　　　　{% csrf_token %}

　　3、注释标签　　

　　　　单行注释 {# #}

　　　　多行注释 {% comment %}。。。。。{% endcomment %}

　　4、过滤器

　　　　模板过滤器可以在变量被显示前修改它。

　　　　语法： {{ 变量 | 过滤器}}

　　　　过滤器使用管道字符 |

　　　　例如： {{name | lower}}  , {{name]} 变量被过滤器 lower处理后文档大写转换为小写

　　　　过滤器管道可以被套接 ， 一个过滤器管道的输出又可以作为下一个管道的输入：

　　　　　　　　{{name|first|upper}} 将变量的第一个元素转换为大写

　　　　过滤器传参：

　　　　　有些过滤器可以传递参数，过滤器的参数跟随冒号之后，并总是以双引号包含

　　　　　　例如：{{bio | truncacteword: "30"}} 截取显示变量bio的前30个单词

　　　　　　　　　　{{name | join:","}} j将name的所有元素使用 逗号 连接起来。

　　　　其他过滤器：

　　　　　　

　　　　　　date：按照指定的格式字符串参数格式化date，或者datetime对象，实例：

　　　　　　　　{{ name.date | date: "Y n j"}}

　　　　　　　　Y: 2018年

　　　　　　　　n:1-12月

　　　　　　　　j：1-31日

　　　　　　　　时间的格式字符串查看：https://docs.djangoproject.com/en/2.0/ref/templates/builtins/#date

测试：使用下面的额字典my_dict 的c的列表，在模板网页中列表ul 输出多行数据：

　　1、奇偶行颜色不同

　　2、每行有行号

　　3、列表中所有的数据都增大100

　　　方式1：

　　　　　

　　方式2：将上面的组合一下

　　　　

　　　　　　

 测试：打印九成九的乘法表

　　　　方式1： 视图提供函数：将 i * j = x 作为字符串，views.py提供数据，index.html显示

　　　　

　　　　

　　　方式2 ：内建标签：widthratio：直接通过index.html 计算得出结果，并显示：

　　　　widthratio本意是计算宽度比率的。

　　　　widthratio用法：{% widthratio value max_value max_width %}

　　　　举例：

　　　　　　{% widthratio 175 200 100 %} ===> 175/200 * 100 = 87.5 四舍五入 88

　　　　　　{% widthratio i 1 j as product %} 别名就可以在后面引用这个变量product

　　　　

　　　　

　　　　　　使用cycle标签来替换奇偶行变色代码

　　　　　　

　　　　as  product：

　　　　

　　方式3 ：自定义filter  

1. 1. 构建自定义的模板 的包和模块

　　　　　　　在应用user下构建templateags 包，一定要有__init__.py 文件

　　　　　　　构建自己的filter的模块，这里起名为myfilters.py其中代码如下

　　　　　　

　　　　　　index.html:

　　　　　　

　　　　　　处理函数：

　　　　　　　

　　　　　　记得把 应用注册一下：settings.py

　　　　　　

　　　　　　事实上如： 1|yesno:"y,n,none" 其实也是 类似，两种参数，1，“y,n,none”   后者切割后做处理

　　　　　　自定义的filter中不能使用关键字参数

5、用户功能设计与实现

　　提供用户注册处理

　　提供用户登录处理

　　提供路由配置

　　5.1、用户注册接口设计：

　　　　接受用户通过Post 方法提交的注册信息，提交的数据是JSON格式的数据

　　　　检查email 是否已存在于数据库表中，如果存在，返回错误状态吗。例如4XX，如果不存在，将用户提交的数据存入表中

　　　　整个过程都采用AJAX 异步过程，用户提交JSON数据，服务端获取数据后处理，返回JSON

　　　　URL：/user/reg

　　　　METHOD: POST

　　5.2、路由配置：

　　　　为了避免项目中的urls.py 条目过多，也为了让应用自己管理自己的路由，采用多级路由。

　　　　# blog/urls.py (项目根目录下）

　　　　　　

　　　　　　include 函数参数写  应用.路由模块  ，该函数就会动态导入指定的包的模块，从模块里面兑取urlpatterns，返回三元组。

　　　　　　url函数第二参数如果不是可调用对象，如果是元组或列表，则会从路径中除去已经匹配的部分，将剩余部分与应用中的路由模块的urlpatterns进行匹配

　　　　新建user/urls.py: 
　　　　　　

　　　　对user/urls.py修改如下：

　　　　　　　　

　　　　bolg/urls.py:

　　　　　　

　　　　user/view.py:

　　　　　　

　　　　浏览器显示:

　　　　　　

　　　　　　过程：

　　　　　　　　输入127.0.0.1:8000/user/reg  先到项目根目录下的 ursl.py 的urlpatterns 匹配

　　　　　　　　匹配到后，截断，剩下 reg/ 因为incldue 应用.模块 下，继续匹配

　　　　　　　　直到匹配到 reg，调用reg处理函数，进行处理。

　　　　　　开发过程建议使用多级。

　　5.3、视图函数：

　　　　在user/view.py中编写视图函数reg，路由做响应的调整

　　　　测试JSON数据

　　　　　　使用POST方法，提交的数类型为application/json, json 字符串要使用双引号

　　　　　　这个数据是登录和注册用的，由客户端提交

 　　　　　　

　　　　　　

　　　　JSON数据处理：

　　　　　　simplejson 比标准库方便好用，功能强大。

　　　　　　$pip install simplejson　

 　　　　　　浏览器端提交的数据放在额请求对象的body'中，需要使用simplejson解析，解析的方式同json，但是前者更方便

　　　　　　

　　　　　　测试的时候，不要出现特殊字符，出现问题，会有提示：

　　　　　　

　　　　错误处理：

　　　　　　注意：Http404  和 HttpResponseNotFound的区别：

　　　　　　   

 　　　　　　Django中有跟多异常类，定义在django.http下，这些类都继承自HttpResponse

　　　　　　　

　　　　　　user/view.py 中：　　　　

from django.shortcuts import render

# Create your views here.
from django.http import  JsonResponse, HttpRequest,HttpResponse,HttpResponseBadRequest
import simplejson
from .models import User
# 注册（业务） insert
def reg(request:HttpRequest):
    try:
        play = simplejson.loads(request.body)
        print(play)
        email = play["email"]
        name = play["name"]
        password = play["password"]
        # ORM 操作
        user = User()
        user.email = email
        user.name = name
        user.password = password
        try: # 这个try可以去掉，不要把e法到浏览器端,
            # 这个try里可以做些特殊处理；
            user.save() # commit提交
            return JsonResponse({"user_id":user.id})
        except Exception as e:
            print(e)
            # return HttpResponseBadRequest("参数错误")
            raise # 直接往外抛，外面的接住。
    except Exception as e:
        print(e)
        return HttpResponseBadRequest("参数错误")

6、CSRF处理

　　在Post数据的时候，发现出现下面的提示：

　　　　

　　原因是：默认Django会对所有的PSOT信息做CSRF校验

　　　　CSRF（Cross-Site request forgery）跨站请求伪造，通常缩写为CSRF 或者XSRF，是一种对网站的恶意利用。

　　　　CSRF 则通过伪装来自受信任的用户的请求来利用受信任的网站

　　　　CSRF 攻击往往难以防范，具有非常大的危险

　　　　　　Django提供CSRF机制：

　　　　　　Django第一次响应来自某个客户端的请求时，会在服务器端随机生成一个token，把这个token放在cookie里，然后浏览器每次POST请求带上这个token，Django的中间件验证，这样就能避免被CSRF攻击（到View之前，有中间件，阻挡了）

　　　解决办法：　　　

　　　　　　1、关闭scrf 中间件，不推荐（settings.py）

　　　　　　

　　　　　　2、在POST提交时，需要发送给服务器一个csrf_token

　　　　　　　　模板中的表单Form中增加 {% csrf_token %} ,它返回到了浏览器端就会为cookie增加csrftoken字段，

　　　　　　　　还会在表单中增加一个名为csrfmiddlewaretoken隐藏空间 <input type='hidden' name='csrfmiddlewretoken'

　　　　　　　　value.....

　　　　　　　　

　　　　　　　　cookie：

　　　　　　　　

　　　　　　3、如果使用AJAX进行POST，需要在请求Header中增加X-CSRFTOKEN，其值来自cookie中获取的csrftoken值

　　　　　　　　

　　　　　　　　第一次请求，返回时，就会带有，所以再次请求，带上这个token就可以

7、邮箱检查

　　邮箱检查需要查user表，需要使用User类的filter方法

　　email = email，前面是字段名email，后面是email变量，查询后，返回结果，如果查询有结果，则说明该email已经存在，邮箱已经注册，返回400到前端。

　　测试代码：　　　

from django.shortcuts import render

# Create your views here.
from django.http import  JsonResponse, HttpRequest,HttpResponse,HttpResponseBadRequest
import simplejson
from .models import User
# 注册（业务） insert
def reg(request:HttpRequest):
    try:
        play = simplejson.loads(request.body)
        print(play)
        email = play["email"]
        query = User.objects.filter(email=email)
        print(type(query),'===================') # 查询语句集
        ## <class 'django.db.models.query.QuerySet'> ===================
        # print(query.query,'===================') # 显示查询语句集
        if query.first():# 懒惰，只要用，就会查
            print('===== 查到了 =======')
            return HttpResponseBadRequest('用户名存在')
        
        name = play["name"]
        password = play["password"]
        # ORM 操作
        user = User()
        user.email = email
        user.name = name
        user.password = password
        try: # 这个try可以去掉，不要把e法到浏览器端,
            # 这个try里可以做些特殊处理；
            user.save() # commit提交
            return JsonResponse({"user_id":user.id})
        except Exception as e:
            print(e)
            # return HttpResponseBadRequest("参数错误")
            raise # 直接往外抛，外面的接住。
    except Exception as e:
        print(e)
        return HttpResponseBadRequest("参数错误")

　　

 

8、用户信息存储：　　　　　　　　　　

　　创建User类实例，属性存储数据，最后调用save方法，Django默认是在save（），delete(）的时候事务自动提交

　　如果提交抛出任何错误，则捕获此异常做相应处理。

　　异常处理：

• • 出现获取输入框提交信息异常，就返回异常
  • 查询邮箱存在，返回异常
  • save（）方法保存数据，有异常，则向外抛出，捕获返回异常
  • 注意一点，Django的异常类继承自HttpReaponse类，所以不能raise， 只能retun

　　　　　　（raise是python自己的，怎么可能raise异常到浏览器端呢）

• • 前端通过状态码判断是否成功

9、Django日志：

　　https://docs.djangoproject.com/zh-hans/2.1/topics/logging/

　　　　settings.py：配置

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console': {
            'class': 'logging.StreamHandler',
        },
    },
    'loggers': {
        'django.db.backends': {
            'handlers': ['console'],
            'level': 'DEBUG',
        },
    },
}

　　　　Django的日志配置在settings.py中

　　　　必须DEBUG=True，否则logger的级别够也不打印日志

　　　　

　　　　配置后，控制台：

　　　　

10、模型操作

　　管理器对象

　　　　Django会为模型类提供一个objects对象，它是django.db.models.manager.Manager类型，用于与数据库交互。

　　　　当定义模型类的时候，没有指定管理器，则Django会为模型类提供一个objects的管理器。

　　　　如果在模型类型中手动指定管理器后，Django不再提供默认的objects的管理器了

　　　　管理器是Django的模型进行数据库查询操作的接口，Django应用的每个模型都至少拥有一个管理器　

　　Django ORM

　　　　数据的校验 validation 是在对象的Save，update方法上

　　　　

 　　　　对模型对象的CRUD， 被Django ORM 转换成相应的SQL 语句操作不同的数据源。

 　　查询：

 　　　　查询集

 　　　　　　查询会返回结果的集，它是django.db.models.query.QureySet类型

　　　　　　 它是惰性求值，和sqlalchemy 一样，结果就是查询的集。

 　　　　　　它是可迭代对象、

 　　　　　　1、惰性求值：

　　　　　　　　创建查询集不会带来任何数据库的访问，知道调用方法使用数据时，才会访问数据库。在迭代，序列化，if语句中都会立即求值

　　　　　　 2、缓存：

　　　　　　　　每一个查询集 都包含一个缓存，来最小化对数据库的访问。

　　　　　　　　新建查询集，缓存为空，首次对查询集求值时，会发生数据库查询，Django会把查询的结果存在这个缓存中，并返回请求的结果，接下来对查询集求值将使用缓存的结果。

 　　　　　　　　观察下面的2个例子是要看真正生成的语句了。

 　　　　　　　　1） 没有使用缓存，每次都要去查库，查了2次

[user.name for user in User.object.all()]
[user.name for user in User.object.all()]

 　　　　　　　　2） 下面的语句使用了缓存，因为使用同一个结果集

qs = User.object.all()
[user.name for user in qs]
[user.name for user in qs]

　　　　限制查询集（切片）

　　　　　　查询集对象可以直接使用索引下标的方式（不支持负索引），相当于SQL语句中的limit和offset子句

　　　　　　注意使用索引返回的新的结果集，依然是惰性求值，不会立即查询（前包后不包（offset，limit））

　　　　　　

　　　　　　

　　　　　　

　　　过滤器：返回查询集的方法

名称	说明
all（）	所有
filter()	过滤，返回满足条件的数据
exclude()	排除，排除满足条件的数据
order_by()	排序
values()	返回一个对象字典的列表，列表的元素是字典，字典内是字段和值的兼职对

    users3 = User.objects.all() # select * from
    users4 = User.objects.values()
    print(users4,'======= 1 ============')
    '''
    <QuerySet [{'id': 2, 'name': 'jack', 'email': 'jack@qq.com', 'password': '123456'}, {'id': 3, 'name': 'jer', 'email': 'jerry@qq.con', 'password': '123456'},
 {'id': 4, 'name': 'tom', 'email': 'tom@qq.com', 'password': 'tom'}, {'id': 5, 'name': 'tom1', 'email': 'tom1@qq.com', 'password': 'tom1'}, {'id': 8, 'name'
: 'tom2', 'email': 'tom2@qq.com', 'password': 'tom1'}, {'id': 12, 'name': 'tom3', 'email': 'tom3@qq.com', 'password': 'tom3'}]> ======= 1 ============
    '''
    print(list(users4))

    users5 = User.objects.filter(name='jack')
    print(users5,'========== 2 ==========')
    # <QuerySet [<User: <user2jack>]> ========== 2 ==========

    users6 = User.objects.exclude(name='jack')
    print(users6)
    # <QuerySet [<User: <user3jer>, <User: <user4tom>, <User: <user5tom1>, <User: <user8tom2>, <User: <user12tom3>]>

    users7 = User.objects.order_by()
    print(users7,'====')
    '''
    (0.001) SELECT `user`.`id`, `user`.`name`, `user`.`email`, `user`.`password` FROM `user` LIMIT 21; args=()
    <QuerySet [<User: <user2jack>, <User: <user3jer>, <User: <user4tom>, <User: <user5tom1>, <User: <user8tom2>, <User: <user12tom3>]> ====
    '''

　　　　　　　　filter(k1=v1).filter(k2=v2) 等价于 filter(k1=v1, k2=v2)  这是  and

　　　　　　　　filter（pk=10）这里的pk指的是主键，不用关心字段名字，当然也可以以使用主键的字段名

　　　　　　返回单个值的方法

名称	说明
get()	仅返回单个满足条件的对象，如果未能返回对象则抛出DoesNotExist异常，如果能返回多条，抛出MultipleObjectsReturned异常
count()	返回当前查询的总条数
first()	返回第一个对象
last()	返回最后一个对象
exist()	判断查询集中是否有数据，如果有返回True

　　　　　　　　　　　　

　　　　　　字段查询（Field lookup）表达式
　　　　　　　　字段查询表达式可以作为 filter() ，exclude()， get（）的参数，实现where子句　　

　　　　　　　　语法：属性（字段）名称_比较运算符=值

　　　　　　　　注意：属性名和运算符之间使用双下划线

　　　　　　　　比较运算符如下：

名称	举例	说明
exact	filter(isdelete=False) filter(isdeleted__exact=False)	严格等于，可省略不写
contains	exclude(title__contains='天‘)	是否包含，大小写敏刚，等价like ‘%天%’
startswith endswith	filter(title__startswith="T")	以什么开头或结尾，大小写敏感
isnull isnotnull	filter（title__isnull=False）	是否为null
iexact icontains istartwith iendwith		i 的意思是忽略大小写
in	filter(pk__in=[1,2,3])	是否在指定范围
gt，gte lt，lte	filter(id__gt=3)	大于，大于等于 小于，小于等于
year，month，day，week_day，hour，minute，second	filter(pub_date__year=2000)	对日期类型属性处理

　　　　　　

　　　　　　Q对象

　　　　　　　　虽然Django提供传入条件的方式，但是不方便，filter无法实现 or，它还提供了Q对象来解决

　　　　　　　　Q对象是Django.db.models.Q  可以使用& （and）,   | (or) 操作符来组成逻辑表达式，~ 表示not

　　　　　　　　

　　　　　　　　可以使用 & | 和 Q 对象来构造复杂的逻辑表达式

　　　　　　　　过滤器函数可以使用一个或多个Q对象

　　　　　　　　如果混用关键字参数和Q对象，那么Q对象必须放在关键字参数的前面，所有参数都将and在一起

11、注册接口设计完善

　　认证：

　　　　HTTP协议是无状态协议，为了解决它产生了cookie和session技术

　　传统的session-cookie 机制

　　　　浏览器发起第一次请求到服务器，服务器发现浏览器没有提供session id，就认为这是第一次请求，会返回一个新的session id给浏览器，浏览器只要不关闭，这个session id 就会随着每一次请求重新发给服务器端，服务器端查找这个session id，如果查到，就认为是同一个会话，如果没有查到，就认为是新的请求。

　　　　session是会话级别的，可以在这个会话session 中创建很多数据，连接断开session清除，包括session id

　　　　这个session id还得有过期的机制，一段时间如果没有发起请求，认为用户已经断开，就清除session。浏览器端也会清除响应的cookie信息

　　　　服务器端保存着大量的session 信息，很消耗内存，而且如果多服务器部署，还要考虑session共享的问题。比如redis，memcached等方案

　　　　（会话（session）和连接不能一一对应,session是证明同一个用户）

　　　　csrf_token:解决安全

　　　　session id：会话id

　　　　

　　　　

　　　　cookie分为两种：

　　　　　　持久cookie：设置了过期时间，没有过期之前，cookie信息会落地，知道过期

　　　　　　会话cookie：关闭浏览器就失效

　　无session方案

　　　　既然服务器端就是需要一个ID来表示身份，name不使用session也可以创建一个ID 返回给客户端，但是要保证客户端不可篡改

　　　　服务器生成一个表示，并使用某种算法对标识签名

　　　　服务器收到客户端发来的标识，需要检查签名。

　　　　这种方案的缺点是，加密，解密需要消耗CPU计算资源，无法让浏览器自己主动检查过期的数据以清除。

　　　　这种技术成为：JWT（Json WEB Token）

　　JWT：可以实现单点登录（另一台服务器登录，只需要验证就行）

　　　　优点：用来保持状态，同时解决了cookie可以改变的问题，还有解决了session存储，共享的问题，因为本身不需要session了

　　　　不能解决身份伪造

　　　　JWT：是一种采用json方案安装传输信息的方式

　　　　这次使用PyJWT，它是python对JWT的实现。

　　　　文档：https://pyjwt.readthedocs.io/en/latest/

　　　　安装：$ pip install pyjwt

　　　　JWT原理：　　　　　

import jwt

key = "seret"

token = jwt.encode({'a':"a"}, key, "HS256")
print(token)
# b'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJhIjoiYSJ9._sX8rOc7ZDAxDInF4sh53zjv__PQO4-pAcDdR9pXYN8'
print(jwt.decode(token, key, algorithms=['HS256']), type(jwt.decode(token, key, algorithms=['HS256'])))
# {'a': 'a'} <class 'dict'>

header, payload, signature = token.split(b'.')
print(header)
print(payload)
print(signature)

import  base64
def addeq(b:bytes):
    ''' 为 base64 编码补齐等号'''
    rest = 4 - len(b) % 4
    return  b + b'=' * rest

print('header=', base64.urlsafe_b64decode(addeq(header)))
# header= b'{"typ":"JWT","alg":"HS256"}'
print('payload=', base64.urlsafe_b64decode(addeq(payload)))
# payload= b'{"a":"a"}'
print('signature=', base64.urlsafe_b64decode(addeq(signature)))
# signature= b'xfexc5xfcxacxe7;d01x0cx89xc5xe2xc8yxdf8xefxffxf3xd0;x8fxa9x01xc0xddGxdaW`xdf'

# 根据jwt算法，重新生成签名
# 1 获取算法对象
from jwt import algorithms
alg =  algorithms.get_default_algorithms()['HS256']
newkey = alg.prepare_key(key)
print(newkey)# b'seret'

# 2、获取前两部分 header payload
signing_inpur, _ , _ = token.rpartition(b'.')
print(signing_inpur)

# 3、使用key 签名
signature = alg.sign(signing_inpur, newkey)

print('=======================================')
print(signature)
print(base64.urlsafe_b64encode(signature))

 　　　　　　结果：

b'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJhIjoiYSJ9._sX8rOc7ZDAxDInF4sh53zjv__PQO4-pAcDdR9pXYN8'
{'a': 'a'} <class 'dict'>
b'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9'
b'eyJhIjoiYSJ9'
b'_sX8rOc7ZDAxDInF4sh53zjv__PQO4-pAcDdR9pXYN8'
header= b'{"typ":"JWT","alg":"HS256"}'
payload= b'{"a":"a"}'
signature= b'xfexc5xfcxacxe7;d01x0cx89xc5xe2xc8yxdf8xefxffxf3xd0;x8fxa9x01xc0xddGxdaW`xdf'
b'seret'
b'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJhIjoiYSJ9'
=======================================
b'xfexc5xfcxacxe7;d01x0cx89xc5xe2xc8yxdf8xefxffxf3xd0;x8fxa9x01xc0xddGxdaW`xdf'
b'_sX8rOc7ZDAxDInF4sh53zjv__PQO4-pAcDdR9pXYN8='

Process finished with exit code 0

 　　　　由此，可知JWT 生成的token分为 三部分

1. 1. header，由数据类型，加密算法构成
   2. payload， 负载要传输的数据，一般来说，放入Python对象即可，会被json序列化
   3. signature，签名部分，是前面2部分数据分别base64 编码后使用点号连接后，利用加密算法使用（key + 前两部分）计算好一个结果，在被base64 编码，得到签名

 　　　　所有数据都是明文传输的，只是做了base64 编码，如果是敏感信息，请不要使用jwt

　　　　数据签名的目的不是为了隐藏数据，而是保证数据不被篡改，如果数据篡改，发回服务器，服务器使用自己的key在计算以便，然后进行签名比对，一定对不上签名。

 　　　　应用场景：

　　　　　　认证：这是jwt 最常用的场景，一旦用户登录成功，就会得到jwt，然后请求中就可以带上这个jwt，服务器中jwt验证通过，就可以允许访问资源，甚至可以在不同域名中传递，在单点登录（single sign on）中应用广泛，

　　　　　　数据交换：jwt可以防止数据被篡改，他可以使用公钥，私钥，确保请求的发送者是可信的。

 　　　　　　

 12、密码：

　　使用邮箱 +密码登录方式

　　邮箱要求唯一就行。密码如何存储？

　　 ---： MD5存储，但是目前也不安全，网上很多MD5的网站，使用反查能找到密码

　　 ---：加盐，使用 hash（password +salt）的结果存入数据库中，就算拿到数据库的密码反查，也没有用了，如果是固定加盐，还是容易被找到规律的，或者从原码中泄露，随机加盐，每一次盐都变，就增加了破解难度。

　　暴力破解：什么密码都可能被暴力破解，所以，使用慢hash算法，例如 bcrypt，就会让每一次计算都很慢，都是秒级别的，这样穷举来破解化的时间会很长。

　　bctypt　

　　　　安装：pip install bcrypt

　　　　测试：　　　　

import bcrypt
import datetime

password = b'123456'

# 每次拿到的盐不一样
print(1, bcrypt.gensalt())
print(2, bcrypt.gensalt())

salt = bcrypt.gensalt()
# 拿到的盐相同，计算的到的密文相同
x = bcrypt.hashpw(password, salt)
print(3, x)
x = bcrypt.hashpw(password, salt)
print(4, x)

# 每次拿到的盐不同，计算生成的密文也不一样
x = bcrypt.hashpw(password, bcrypt.gensalt())
print(5, x)
x = bcrypt.hashpw(password, bcrypt.gensalt())
print(6, x)
print('====' * 20)
# 校验
print(bcrypt.checkpw(password, x), len(x))
print(bcrypt.checkpw(password+b'  ', x), len(x))

# 计算时长
start = datetime.datetime.now()
y = bcrypt.hashpw(password, bcrypt.gensalt())
delta = (datetime.datetime.now() - start).total_seconds()
print(y)
print(10, delta)

# 检验时长
start = datetime.datetime.now()
y = bcrypt.checkpw(password, x)
delta = (datetime.datetime.now() - start).total_seconds()
print(y,'====')
print(11, delta)


start = datetime.datetime.now()
y = bcrypt.checkpw(b'1', x)
delta = (datetime.datetime.now() - start).total_seconds()
print(y)
print(12, delta)

　　　　结果：

F:pyenvslog2Scriptspython.exe F:/Python项目/blog12/test.py
1 b'$2b$12$lNtU.U.dpmTIAaQjWLnF5.'
2 b'$2b$12$Vo0ulFEzzing3kM6fXTu2u'
3 b'$2b$12$Nr/Y2w9zyyJtnUqrqW6SCuXRM8PlDxDr9HZM3zViRdEGjOWt5UyvG'
4 b'$2b$12$Nr/Y2w9zyyJtnUqrqW6SCuXRM8PlDxDr9HZM3zViRdEGjOWt5UyvG'
5 b'$2b$12$3XXyg.K9HyI.p24DBEYGi.QdEQobiAgM0i3mz7FUrjoyLRjl6./ou'
6 b'$2b$12$Zoq1fNKR.x70wXQBQZpii.tTk5.FMDnJp7fMIRpPGAYZZO6uA6ajK'
================================================================================
True 60
False 60
b'$2b$12$MwXbhhMvDqLXr5eySavOwu2oQm1dQAZeivj/kKDD27GGSYxj1qrSa'
10 0.34502  可以看到时间是很长的，
True ====
11 0.337019
False
12 0.331019

　　　　从耗时看出，bcrypt 加密，验证非常耗时，所以穷举，非常耗时，而且碰巧攻破一个密码，由于盐不一样，还得穷举另一个

　　　　

13、注册代码  更新

　　全局变量

　　项目settings.py文件实际上就是全局变量的配置文件

　　SECCRET_KEY 一个强密码

　　使用jwt 和bcrypt 　

from django.shortcuts import render

# Create your views here.
from django.http import  JsonResponse, HttpRequest,HttpResponse,HttpResponseBadRequest
import simplejson
from .models import User
from django.db.models.manager import Manager
from django.db.models import Q
import  jwt
import bcrypt
import datetime
12 from django.conf import settings
13 KEY = settings.SECRET_KEY
14 print(KEY)
15 # SECRET_KEY = ')enlwt1x02$&&egj-q&%=-jq2(*4iy^o$le2te@x2inp&bq_7)' ----在blog/settings.py中

# 服务器端生成一个 token
def gen_token(user_id):
    return  jwt.encode({
        'user_id':user_id,
        "timestamp":int(datetime.datetime.now().timestamp()) # 要取整
    },KEY, 'HS256').decode() # 字符串

# 注册（业务） insert
def reg(request:HttpRequest):
    try:
        play = simplejson.loads(request.body)
        # print(play, type(play),'========================')
        email = play["email"]
        a = User.objects.filter(email=email)
        # print(a.query) # 查看查询语句
        if a.first():# 懒惰，只要用，就会查
            return HttpResponseBadRequest('用户名存在')

        name = play["name"]
        # 这两步可以合起来，减少计算
        password = play["password"]
        print(password)
        password = bcrypt.hashpw(password.encode(), bcrypt.gensalt()) ------保证每次的盐都不同，提高安全性
        # ORM 操作
        user = User()
        user.email = email
        user.name = name
        user.password = password

        try: # 这个try可以去掉，不要把e法到浏览器端,
            # 这个try里可以做些特殊处理；
            user.save() # commit提交
            # 如果正常，返回json数据
            return JsonResponse({"token":gen_token(user.id)})
        except Exception as e:
            print(e)
            # return HttpResponseBadRequest("参数错误")
            raise # 直接往外抛，外面的接住。
    except Exception as e: # 有任何异常返回。
        print(e)
        return HttpResponseBadRequest("参数错误") # 这里返回实例，这不是异常类，继承自httpresponse

def show(request:HttpRequest):
    ################################################################################
    #Q对象
    return JsonResponse({})