火之影 有思念你的人的地方就是你的归处 2021-02-01T02:53:11.939Z http://yoursite.com/ 火之影 Hexo 使用Go处理HTTP压缩文件数据总结 http://yoursite.com/2021/02/01/使用Go处理HTTP压缩文件数据总结/ 2021-01-31T16:01:33.000Z 2021-02-01T02:53:11.939Z 前言

最近遇到了一个HTTP请求返回一个gz压缩包的问题，前前后后搞了3天，总算是把整个流程以及处理的细节搞明白了，总结一篇博客记录分享一下。

问题描述及解决方案

流量方的优化

获取某推广告成效数据的时候由于数据量很多，可能会导致Response数据量过大从而造成请求失败的问题。
某推服务方设计了这样一种方式：先将请求的到的数据写入到一个json文件中，然后将这个json文件使用gzip压缩（经过实际测试，一个100多k大小的json文件使用gzip压缩后只有十几k的大小，并且gzip压缩后是不保留原文件的）。
最终服务端存的是一个压缩后的gz文件，然后返回给用户端一个链接，用户根据这个链接去“下载”压缩后的数据文件，大大减少了网络带宽的占用！
比如我们可以通过下面这个链接下载成效数据：成效数据链接
也就是说，与我们平时处理的请求不同的是，现在这种情况下发送GET请求得到的是一个gz文件的数据流。

解决思路

其实解决问题的思路有2个：一个是根据gz数据流将gz文件写入到本地，然后在本地解压这个文件，读取解压后的文件；另外一种思路是直接根据gz数据流将json文件解压到本地，省去了中间在本地生成gz压缩文件的过程！
一目了然：在上面描述的业务场景中，肯定是第二种解决方案最优！

优化的第三方包

从网上找了一个包去处理文件解压缩的问题，但是其源码本身有一些问题，略微修改了一下其源码后便可使用了。
最终修改后的项目地址请访问：Unpackit
原文件存在的问题可以看README的描述。

解决问题的demo

自己写了一个demo专门用来展示两种解决方案的实现过程。
麻雀虽小，五脏俱全，这个demo用到了自定制错误、http的连接池，以及go中常用的错误返回机制。
项目地址如下，欢迎star：https://gitee.com/huoyingwhw/unpackit-demo

细节记录

关于一些解决问题中间的细节请查看笔者另外2篇博客：
使用Golang解压缩文件遇到的问题及解决方法
使用unpackit包解压gz包遇到的一个问题与解决方案

]]> <h3 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h3><p>最近遇到了一个HTTP请求返回一个gz压缩包的问题，前前后后搞了3天，总算是把整个流程以及处理的细节搞明白了，总结一篇博客记录分享一下。 个人Golang学习资源总结 http://yoursite.com/2021/01/30/个人Golang学习资源/ 2021-01-30T14:24:05.000Z 2021-02-01T02:40:39.765Z 下半年做了大半年的Go项目，边学边实现业务功能的的同时也不断记录平时遇到的问题以及解决方案，学习笔记与问题记录主要放在了mkdocs与博客园中，欢迎访问：
Golang服务端入门与进阶指南
个人Golang整合博客

]]> <p>下半年做了大半年的Go项目，边学边实现业务功能的的同时也不断记录平时遇到的问题以及解决方案，学习笔记与问题记录主要放在了<code>mkdocs</code>与<code>博客园</code>中，欢迎访问：<br><a href="https://huoyingwhw.co 个人Python学习资源总结 http://yoursite.com/2020/06/08/个人学习资源总结/ 2020-06-08T11:13:01.000Z 2021-02-01T02:29:09.619Z 这一阵子一直没有更新个人博客，主要是将大部分的精力都放在了使用mkdocs搭建的个人文档上面。
使用mkdocs进行知识点的记录与分享确实方便很多，欢迎大家访问我的个人文档：
Python服务端入门与进阶指南
Django使用指南

]]> <p>这一阵子一直没有更新个人博客，主要是将大部分的精力都放在了使用<code>mkdocs</code>搭建的个人文档上面。<br>使用mkdocs进行知识点的记录与分享确实方便很多，欢迎大家访问我的个人文档：<br><a href="https://huoyingwhw.co Python中defaultdict的使用 http://yoursite.com/2020/02/10/Python中defaultdict的使用/ 2020-02-10T14:23:02.000Z 2020-02-10T14:31:17.679Z 在实际中使用defaultdict会十分效率地为我们构建不同格式的数据，通常需要好几层循环构建的数据如果巧用defaultdict的话使用一层循环便可实现，这一点笔者深有体会！本文就为大家总结一下使用defaultdict构建数据的一些实例。

整合相同类型的数据

现有如下的数据：

1
2
3
4
5
6
7
res = [
{"ID":111,"HOUSE":1},
{"ID":222,"HOUSE":1},
{"ID":333,"HOUSE":1},
{"ID":444,"HOUSE":2},
{"ID":555,"HOUSE":2},
]

我们需要将相同HOUSE的ID整合到一起，然后以每个ID为key，找到每个ID对应的详情，想要的结果如下（每个ID对应的detail信息是从其他接口获取的）：

1
2
3
4
5
6
7
8
9
10
11
{
    1: {
        111: {111:"detail111"},
        222: {222:"detail222"}, 
        333: {333:"detail333"}
       },
    2: {
        444: {444:"detail444"}, 
        555: {555:"detail555"}
    }
}

这里就不介绍其他的方法了，有兴趣的同学可以自己试试，这里直接给出defaultdict的方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
from collections import defaultdict

# 这里defaultdict默认的元素是dict
ret = defaultdict(dict)

res = [
{"ID":111,"HOUSE":1},
{"ID":222,"HOUSE":1},
{"ID":333,"HOUSE":1},
{"ID":444,"HOUSE":2},
{"ID":555,"HOUSE":2},
]

for i in res:
    # 可以从其他接口中获取ID对应的detail，这里就省略了，直接用固定的字符串代替
    detail = f"detail{i['ID']}"
    ret[i["HOUSE"]].update({i["ID"]:{}})
    ret[i["HOUSE"]][i["ID"]].update({i["ID"]:detail})

print(ret) 
# defaultdict(<class 'dict'>, {1: {111: {111: 'detail111'}, 222: {222: 'detail222'}, 333: {333: 'detail333'}}, 2: {444: {444: 'detail444'}, 555: {555: 'detail555'}}})

可以看到最终得到一个defaultdict对象，是一个自定义的字典，其实它可以被强转为一个dict对象，但是强转没有意义，将得到的结果可以直接当做是一个字典对象就可以。
我们看一下默认字典的声明：

1
2
from collections import defaultdict
ret = defaultdict(dict)

这样的声明之后，我们可以将ret看成一个字典对象，这个字典对象中默认的元素是dict（就是上面defaultdict中的参数），声明之后我们可以将ret当做是一个字典来进行操作，对ret中的元素可以进行字典的操作（defaultdict中用什么元素就可以使用对应的方法，比如上面例子用到了dict的update方法）。

其他的例子

如果上面的说明你还没有看明白的话，笔者这里列举一些常见的例子帮助大家理解。

合并字符串

下面这个例子其实是笔者之前遇到的一个面试题，在此分享一下：
有如下两个列表：

1
2
a = ['a,1', 'b,3,22', 'c,3,4', 'f,5', ]
b = ['a,2', 'b,4', 'w,12', 'd,2','c,123']

需要将两个列表中有相同字母的字符串合并，合并后的结果如下：

1
c = ['a,1,2', 'b,3,22,4', 'c,3,4,123', 'f,5', 'w,12', 'd,2']

当初年轻的我是这么做的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# -*- coding:utf-8 -*-
a = ['a,1', 'b,3,22', 'c,3,4', 'f,5', ]
b = ['a,2', 'b,4', 'w,12', 'd,2','c,123']

dic = {}
for i in a:
    dic[i[0]] = i
print(dic)

for i in b:
    if i[0] in dic:
        dic[i[0]] += i[1:]
    else:
        dic[i[0]] = i
print(dic)
print(list(dic.values()))

其实使用defaultdict的话会很方便：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# -*- coding:utf-8 -*-
from collections import defaultdict

a = ['a,1', 'b,3,22', 'c,3,4', 'f,5', ]
b = ['a,2', 'b,4', 'w,12', 'd,2','c,123']

dic = defaultdict(str)

for i in a:
    dic[i[0]] = i
dic = dict(dic)
print(dic)

for i in b:
    if i[0] in dic:
        dic[i[0]] += i[1:]
    else:
        dic[i[0]] = i
print(dic)
print(list(dic.values()))

这里可以看到：defaultdict中的元素是str，因此我们在构建数据的时候可以使用字符串拼接的方式。

统计颜色数量

现有如下的数据：

1
lis = [('红色',1),('白色',2),('绿色',3),('紫色',1),('红色',1),('白色',1),('红色',1),('粉色',1),]

统计一下每个颜色的数量，期望的结果如下：

1
dic = {'红色': 3, '白色': 3, '绿色': 3, '紫色': 1, '粉色': 1}

默认元素选择list，实现方法如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# -*- coding:utf-8 -*-
from collections import defaultdict

### 将每种球与其总数量统计出来
###  {'红色':3,'白色':3,...}
lis = [('红色',1),('白色',2),('绿色',3),('紫色',1),('红色',1),('白色',1),('红色',1),('粉色',1),]

dic = defaultdict(list)

for i in lis:
    dic[i[0]].append(i[1])
dic = dict(dic)
print(dic)
for i in dic:
    dic[i] = sum(dic[i])
print(dic)

默认元素为int，三次登陆失败锁定的简单例子

userinfo文件中的内容如下，作为登陆的用户名密码测试文件：

1
2
3
whw|123
wanghw|123
www|123

locked文件中存放的是被锁定的用户名。
实现一个简单的三次登陆失败锁定的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
# -*- coding:utf-8 -*-
from collections import defaultdict

# 默认value设置成0
dic = defaultdict(int)

# 这里设置一个flag，while循环的额条件是flag；
# 如果循环内还有一层循环，跳出内层循环若需要跳出整个循环可以将flag设置成False！
flag = True
while flag:
    username = input('用户名：').strip()
    password = input('密码：').strip()
    # 先判断账号有没有被锁定
    with open('locked','r',encoding='utf-8')as f:
        for line in f:
            if username == line.strip():
                print('该账号已被锁定！')
                flag = False
                break
    # 默认字典 —— 确保 “每个用户都有三次机会”
    if dic[username] < 2:
        with open('userinfo','r',encoding='utf-8')as f:
            for line in f:
                usr,pwd = line.strip().split('|')
                if usr == username and pwd == password:
                    print('登陆成功！')
                    # 如果想登陆成功后退出while大循环，可以将flag设置为False
                    flag = False
                    # 这个break只是退出for循环
                    break
            else:
                dic[username] += 1
                print('登录失败！用户名或密码错误！')
    else:
        with open('locked','a',encoding='utf-8')as f:
            f.write(username+'\n')
        print('账号被锁定！')
        break
]]> <p>在实际中使用<code>defaultdict</code>会十分效率地为我们构建不同格式的数据，通常需要好几层循环构建的数据如果巧用<code>defaultdict</code>的话使用一层循环便可实现，这一点笔者深有体会！本文就为大家总结一下使用<code>defaultdict</code>构建数据的一些实例。 个人Django学习资源 http://yoursite.com/2020/02/09/个人Django学习资源/ 2020-02-09T09:23:34.000Z 2020-02-09T10:41:10.601Z 最近笔者将自己工作与学习过程中总结的Django的知识点整理了一下，以一篇整合好的博客的方式呈现给大家，希望能帮到正在使用或者学习Django的你，如有好的建议请在对应的文章下面留言。
个人Django资源

]]> <p>最近笔者将自己工作与学习过程中总结的Django的知识点整理了一下，以一篇整合好的博客的方式呈现给大家，希望能帮到正在使用或者学习Django的你，如有好的建议请在对应的文章下面留言。 手写web框架之框架概览 http://yoursite.com/2020/02/05/手写web框架之框架概览/ 2020-02-05T14:05:12.000Z 2020-02-05T15:57:52.774Z 本文介绍的是一个基于WSGI自定制的MVC模式的web框架，拥有路由与模板系统，数据使用pymysql模块进行添加与查询校验，实现的核心是Python内置的wsgiref模块。

项目地址

本项目上传到了github中，大家有兴趣可以自己pull下来玩玩：https://github.com/Wanghongw/whwFrame
关于web框架（或者说web服务）的基础知识点可以参考我之前写过的一篇文章：从零开始带你手撸web服务

项目的目录结构如下

123
如果你使用过Django/Falsk/Tornado或者其他Python框架的话，这样的结构相信你已经非常熟悉了。一个MVC模式的web框架一定会包含数据模型Model、模板、逻辑处理接口、路由控制器这几个要素。
本项目使用pymysql模块进行数据的插入与查询操作，utils包中的脚本是其具体的实现；
templates包中包含该项目用到的模板；
views.py模块中包含多个逻辑处理的接口；
urls.py是路由控制的模块。
manage.py模块是整个框架运行起来的核心，在这里我们使用wsgiref模块中的application方法跑起来一个web服务：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# -*- coding:utf-8 -*-
from urls import urlpatterns
from wsgiref.simple_server import make_server


#这个文件里面是框架的主体内容
def application(environ, start_response):
    start_response('200 OK', [('Content-Type', 'text/html')])
    path = environ['PATH_INFO']
    for url_tuple in urlpatterns:
        if url_tuple[0] == path:
            data = url_tuple[1](environ) #environ要传进去，因为处理逻辑里面可能要用
            break
        else:
            data = b'sorry 404!,not found the page'
    return [data]
        # 注意，我们如果直接返回中文，没有给浏览器指定编码格式，所以我们需要gbk来编码一下，浏览器才能识别
        # data='登陆成功！'.encode('gbk')


httpd = make_server('127.0.0.1', 8080, application)

print('Serving HTTP on port 8080...')
# 开始监听HTTP请求:
httpd.serve_forever()

项目运行方式

1、需要先安装MySQL5.6及以上版本，并在您的MySQl中创建一个名为auth的数据库
2、进入utils包中，运行webData.py文件，在之前创建好的auth数据库中写入数据
3、运行外面的manage.py文件
4、在浏览器中输入127.0.0.1:8080开始您的体验（设置好的用户名为whw，密码为123）

结束语

其实使用web框架的一个好处就是可以提高开发效率，比如说，这个个框架写好了之后，如果我们将来想添加一些新的功能，比如说有人想在网址里面输入http://127.0.0.1:8080/timer 来查看当前的时间。
这样一个需求只需要两步就可以完成：
首先在urls.py中写一个url映射关系：

1
2
3
4
5
6
7
8
9
from views import timer

# url与视图函数的对应关系
urlpatterns=[
    # 其他的路由
    xxx
    # timer的路由映射关系
    ('/timer',timer),
]

然后在views.py加上应对的处理接口就OK了：

1
2
3
4
#查看当前时间的
def timer(environ):
    data = str(datetime.datetime.now()).encode('utf-8')
    return data
]]> <p>本文介绍的是一个基于WSGI自定制的MVC模式的web框架，拥有<code>路由</code>与<code>模板</code>系统，数据使用<code>pymysql</code>模块进行添加与查询校验，实现的核心是Python内置的<code>wsgiref</code>模块。 从零开始带你手撸web服务 http://yoursite.com/2020/01/12/从零开始带你手撸web服务/ 2020-01-12T05:15:13.000Z 2020-01-12T09:28:35.317Z 本文先用一个实例详细讲解了web请求与响应的具体过程并说明了web应用的本质，然后带大家由浅入深地手写了几个不同需求下的web服务端程序，帮助大家从底层理解服务端对web请求的处理过程以及web服务的运行原理，最后介绍了如何使用Python的wsgiref模块实现web请求与响应的处理。

web应用的本质

客户端-服务器模型

其实，对于所有的Web应用来说，从本质上讲我们运行web应用程序的地方就是一个socket服务端，而用户的浏览器就是一个socket客户端，我们可以使用Python的socket模块自己实现一个简单的带并发效果的web服务端: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import socket
from threading import Thread

def run_server(conn):
    msg = conn.recv(65105).decode('utf-8')
    # 打印浏览器的请求信息
    print(msg)
    #需要先根据协议向浏览器发送响应的内容
    conn.sendall(b'HTTP/1.1 200 OK \r\n\r\n')
    conn.sendall(b'Hello WHW!')
    conn.close()

if __name__ == '__main__':
    server = socket.socket()
    #设置端口重复利用
    server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
    server.bind(('127.0.0.1',8990))
    server.listen()
    #建立连接循环
    #由于HTTP是无连接的协议，因此这里必须加连接循环
    while 1:
        conn,_ = server.accept()
        t = Thread(target=run_server,args=(conn,))
        t.start()

这里，我们可以看到，在接收到浏览器的请求127.0.0.1:8990后，这个服务器端首先给浏览器（客户端）发送了一个200 OK的HTTP响应信息，然后发送了字符串Hello WHW!。
我们先运行这个程序然后在浏览器输入：localhost:8990,就可以看到服务器发送出的这个“Hello WHW!”字符串：

1
Hello WHW!

这里解释一下我们给浏览器发送Hello WHW之前：conn.sendall(b'HTTP/1.1 200 OK \r\n\r\n')的意思：
socket是应用层和传输层之间的抽象层，每一层都有协议，所谓的协议协议其实就是固定的消息格式，传输层的消息格式socket已经帮我们封装好了，但是应用层的协议还是需要开发者遵守的，所以在给浏览器发送消息的时候，如果没有按照应用层的消息格式来写，那么你返回给浏览器的信息，浏览器是没法识别的。
而我们web开发用到的应用层的协议都是HTTP协议，所以我们按照HTTP协议规定的消息格式来给浏览器返回消息时浏览器是可以识别的！也就是说，“200 OK”那一行的数据是在告诉浏览器，“请接收并输出我下面发来的数据”，而其实这句话也可以合在一起写：

1
conn.sendall(b'HTTP/1.1 200 OK \r\n\r\nHello WHW!')

其实上面这些还涉及到HTTP协议的版本以及报文格式的问题；还有我们上面的程序其实还打印了浏览器的请求信息：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
GET / HTTP/1.1
Host: 127.0.0.1:8990
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.108 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8
Cookie: csrftoken=OkwsxAS7MZYJB8jz6QZMZI5bGANdSDONk2TUFLbfxHVl0xbKPtvwwm7XGIF7hSM0


# 。。。 其他请求信息

由于本文篇幅有限这里就不一一详细展开说明了，大家有兴趣的话请参考这篇文章：关于HTTP协议，一篇就够了
接着，我们在函数run_server的第二个conn中加上有样式效果的字符串： 

1
conn.sendall(bytes('<h1 style="background-color:red;">Hello WHW!',encoding='utf-8'))

再看看浏览器的返回结果，上面的样式生效了：
111
也就是说，浏览器自动将服务器发送给它的字符串按照一定的规则呈现出对应的效果！

web应用本质揭示

（1）当浏览器作为客户端与运行web程序的服务器端进行交互的时候，服务器给浏览器返回的是“字符串”； （2）如果这些“字符串”中有浏览器能够识别的格式，那么浏览器会自动的将这些包含在字符串中的格式解析成用户看着舒服的“效果”；
（3）而要想在浏览器实现我们想要的效果，我们就必须去学习浏览器都有哪些规则；
（4）我们可以将服务器端send的内容先写进一个文件里，然后将这个文件的内容读出来再发给浏览器，而这个文件，大家“约定俗成”的将其命名成后缀为.html的文件，也就是大家熟悉的html文件。
所以从web开发者的角度讲，我们需要做的事情大致有以下两点：
（1）按照Html的规则编写Html文件——充当模板
（2）从数据库中获取数据，然后替换到Html文件的数据位置——需要学习web框架

手写web服务

了解了web应用的本质后，接下来带大家一步步地手写web服务！

返回html文件的web框架

上面说到了，如果返回的内容比较多的话，在服务端我们可以将一个html文件返回给浏览器。
准备工作：新建一个html文件:index.html，从本地找到一个图片1.jpg与一个图标文件favicon.ico,并且创建一个css文件存放css样式。
index.html文件的内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <!--引入本地的ico文件-->
    <link rel="=icon" href="favicon.ico">
    <!-- 引入本地css文件 -->
    <link rel="stylesheet" href="whw.css">
</head>
<body>
<h1 class="content">你好！世界！</h1>
<div class="d1">
    <!--引入本地的图片-->
    <img src="1.jpg" alt="">
</div>
<script>
    alert('你好世界！')
</script>
</body>
</html>

server端的代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import socket
from threading import Thread

def run_server(conn):
    msg = conn.recv(65105).decode('utf-8')
    print(msg)
    #需要先根据协议向浏览器发送响应的内容
    conn.sendall(b'HTTP/1.1 200 OK \r\n\r\n')
    with open('index.html','rb')as f:
        data = f.read()
        conn.sendall(data)
    conn.close()

if __name__ == '__main__':
    server = socket.socket()
    #设置端口重复利用
    server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
    server.bind(('127.0.0.1',8991))
    server.listen()
    #建立连接循环
    #由于HTTP是无连接的协议，因此这里必须加连接循环
    while 1:
        conn,_ = server.accept()
        t = Thread(target=run_server,args=(conn,))
        t.start()

whw.css文件中的内容如下：

1
2
3
.content{color:red;}
.d1{width:123px;height:123px;}
img{width:100%;height:100%;}

我们在浏览器中输入127.0.0.1:8991看一下结果:
alert弹窗与h1标签自带的效果都有，但是网页中没有显示图片与ico图标，css定制的样式也没有呈现！
这是因为：弹窗与h1标签的效果我们随着html文件发送给了浏览器，但是图片、图标与css文件还在server本地，并没有发送给浏览器，浏览器渲染不出来！
其实针对html文件“引用”的静态文件，浏览器会额外发送相应的请求的，看一下Network中的信息大家就明白了：
222
也就是说：获取index页面浏览器发送请求127.0.0.1:8991，但是想要获取index页面中的静态文件的话，浏览器会在前面的请求的基础上加上静态文件的名字再向服务器“索取”对应位置的静态文件！
其实这些和标签的属性有有关系，css文件是link标签的href属性：<link rel="stylesheet" href="test.css">，js文件是script标签的src属性：<script src="test.js"></script>，图片文件是img标签的src属性：<img src="meinv.png" alt="" width="100" height="100"> ，图标ico文件是link标签的属性：<link rel="icon" href="whw.ico">，其实这些属性都会在页面加载的时候，单独到自己对应的属性值里面取请求对应的文件数据，而且我们如果在值里面写的都是自己本地的路径，那么都会来自己的本地路径来找，如果我们写的是相对路径，就会到我们自己的网址+文件名称，这个路径来找它需要的文件，所以我们只需要在服务接收到这些请求后做出对应的响应，就可以将相应的文件发送给浏览器了！

返回静态文件的web应用

既然浏览器可以根据link标签的href、img标签的src、script标签的src后面的值向服务器端请求对应的文件，那我们完全可以根据这些请求信息将对应为文件发送给浏览器，这样浏览器拿到我们发给它的文件后进行渲染，就可以展现出对应的效果了！对应的服务端程序我们可以这样来写：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
import socket
from threading import Thread

def run_server(conn):
    msg = conn.recv(65105).decode('utf-8')
    # print(msg)
    # 通过http协议我们知道，浏览器请求的时候，有一个请求内容的路径，
    # 通过对请求信息的分析，这个路径我们在请求的所有请求信息中可以提炼出来，下面的path就是我们提炼出来的路径
    path = msg.split('\r\n\r\n')[0].split()[1]
    print('path>>>:',path)
    #需要先根据协议向浏览器发送响应的内容
    conn.sendall(b'HTTP/1.1 200 OK \r\n\r\n')
    #根据不同的路径返回响应的内容
    #返回html文件
    if path == '/':
        with open('index.html','rb')as f:
            data = f.read()
            conn.sendall(data)
            conn.close()
    #返回ico文件是固定的
    #注意图标必须叫favicon.ico
    if path == '/favicon.ico':
        with open('favicon.ico','rb')as f:
            data = f.read()
            conn.sendall(data)
            conn.close()
    #返回图片文件
    if path == '/1.jpg':
        with open('1.jpg','rb')as f:
            data = f.read()
            conn.sendall(data)
            conn.close()
    # 返回css文件
    if path == '/whw.css':
        with open('whw.css','rb')as f:
            data = f.read()
            conn.sendall(data)
            conn.close()

if __name__ == '__main__':
    server = socket.socket()
    #设置端口重复利用
    server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
    server.bind(('127.0.0.1',8991))
    server.listen()
    #建立连接循环
    #首先浏览器相当于给我们发送了多个请求，一个是请求我们的html文件，
    #而我们的html文件里面的引入文件的标签又给我们这个网站发送了请求静态文件的请求，
    #所以我们要将建立连接的过程循环起来，才能接受多个请求
    while 1:
        conn,_ = server.accept()
        t = Thread(target=run_server,args=(conn,))
        t.start()

这时我们再在浏览器中输入127.0.0.1:8991就可以展示图、图标与效果了！

优化一

我们可以使用函数与映射的方式优化一下上面的代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
# -*- coding:utf-8 -*-
import socket

def index(conn):
    with open('index.html','rb')as f:
        data = f.read()
        conn.sendall(data)
        conn.close()

def ico(conn):
    with open('favicon.ico','rb')as f:
        data = f.read()
        conn.sendall(data)
        conn.close()

def img(conn):
    with open('1.jpg','rb')as f:
        data = f.read()
        conn.sendall(data)
        conn.close()

def css(conn):
    with open('whw.css','rb')as f:
        data = f.read()
        conn.sendall(data)
        conn.close()
        

if __name__ == '__main__':
    # 处理的函数列表
    opt_lst = [
        ('/',index),
        ('/favicon.ico',ico),
        ('/1.jpg',img),
        ('/whw.css',css),
    ]
    # 初始化socket
    server = socket.socket()
    #设置端口重复利用
    server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
    server.bind(('127.0.0.1',8991))
    server.listen()
    while 1:
        conn,addr = server.accept()
        msg = conn.recv(65105).decode('utf-8')
        # print(msg)
        #获取path
        path = msg.split('\r\n\r\n')[0].split()[1]
        # 先发送响应的协议
        conn.sendall(b'HTTP/1.1 200 OK \r\n\r\n')
        #根据不同的路径调用相应的函数
        for i in opt_lst:
            if path == i[0]:
                i[1](conn)
优化二

当然可以专门为每个传文件的函数开多线程提高效率，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
# -*- coding:utf-8 -*-
import socket
from threading import Thread

def index(conn):
    with open('index.html','rb')as f:
        data = f.read()
        conn.sendall(data)
        conn.close()

def ico(conn):
    with open('favicon.ico','rb')as f:
        data = f.read()
        conn.sendall(data)
        conn.close()

def img(conn):
    with open('1.jpg','rb')as f:
        data = f.read()
        conn.sendall(data)
        conn.close()
        
def css(conn):
    with open('whw.css','rb')as f:
        data = f.read()
        conn.sendall(data)
        conn.close()
        
def handle(opt_lst,path,conn):
    for i in opt_lst:
        if path == i[0]:
            # 开线程传文件
            t = Thread(target=i[1],args=(conn,))
            t.start()

if __name__ == '__main__':
    # 处理的函数列表
    opt_lst = [
        ('/', index),
        ('/favicon.ico', ico),
        ('/1.jpg', img),
        ('/whw.css',css),
    ]
    # 初始化socket
    server = socket.socket()
    #设置端口重复利用
    server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
    server.bind(('127.0.0.1',8991))
    server.listen()
    #连接循环
    while 1:
        conn,addr = server.accept()
        msg = conn.recv(65105).decode('utf-8')
        # print(msg)
        path = msg.split('\r\n\r\n')[0].split()[1]
        print(path)
        # 先法响应协议
        conn.sendall(b'HTTP/1.1 200 OK \r\n\r\n')
        # 执行handle函数
        handle(opt_lst,path,conn)
优化三

在优化二中我们实现了多线程上传文件，结合前面实现的多线程接收请求，两者可以结合起来写，但是考虑到线程安全的问题，不建议大家这样来写：

多线程接收请求结合多线程上传文件 
import socketfrom threading import Thread
def run_server(conn,opt_lst):
    msg = conn.recv(65105).decode(‘utf-8’)
    # print(msg)
    path = msg.split(‘\r\n\r\n’)[0].split()[1]
    print(path)
    # 先发响应协议
    conn.sendall(b’HTTP/1.1 200 OK \r\n\r\n’)
    # 开多线程执行文件操作
    t = Thread(target=handle,args=(opt_lst,path,conn))
    t.start()
def index(conn):
    with open(‘index.html’,’rb’)as f:
        data = f.read()
        conn.sendall(data)
        conn.close()
def ico(conn):
    with open(‘favicon.ico’,’rb’)as f:
        data = f.read()
        conn.sendall(data)
        conn.close()
def img(conn):
    with open(‘1.jpg’,’rb’)as f:
        data = f.read()
        conn.sendall(data)
        conn.close()
def handle(opt_lst,path,conn):
    for i in opt_lst:
        if path == i[0]:
            i[1](conn)
if name == ‘main‘:
    # 处理的函数列表
    opt_lst = [
        (‘/‘, index),
        (‘/favicon.ico’, ico),
        (‘/1.jpg’, img),
    ]
    # 初始化socket
    server = socket.socket()
    #设置端口重复利用
    server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
    server.bind((‘127.0.0.1’,8765))
    server.listen()
    #连接循环
    while 1:
        conn,addr = server.accept()
        # 开线程处理连接
        t = Thread(target=run_server, args=(conn,opt_lst))
        t.start()

根据不同路径返回独立的页面

根据上面介绍的根据不同的路径返回相应的文件，我们也可以根据不同的路径返回独立的页面。
之前用到的index.html文件我们不考虑外部文件引入的情况，另外再新建一个home.html文件，同样不考虑外部文件引入的情况。
服务端的代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
# -*- coding:utf-8 -*-
import socket

def index():
    with open('index.html','rb') as f:
        data = f.read()
        return data

def home():
    with open('home.html','rb')as f:
        data = f.read()
        return data

if __name__ == '__main__':
    opt_lst = [
        ('/index',index),
        ('/home',home)
    ]
    server = socket.socket()
    server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
    server.bind(('127.0.0.1',8765))
    server.listen()
    while 1:
        conn,addr = server.accept()
        msg = conn.recv(65105).decode('utf-8')
        #path是从请求体中经过处理得到的
        path = msg.split('\r\n\r\n')[0].split()[1]
        print(path)
        #记得发送响应协议！
        conn.sendall(b'HTTP/1.1 200 OK \r\n\r\n')
        for i in opt_lst:
            if i[0] == path:
                func = i[1]
                content = func()
                #一定要记的break！不执行else里的语句
                break
        else:
            content = b'404 Not Found'

        conn.sendall(content)
        conn.close()

这样，我们在浏览器中输入127.0.0.1:8765/index与127.0.0.1:8765/home就可以看到对应的不同网页了。当然～需要其他的静态文件的话再另外做判断就OK了！

返回“动态”页面的web应用的实现

前面我们返回的都是静态网页，实际中的网页都是 动态的——其实所谓的动态网页是里面有可变的数据！
这里我们用字符串的替换方式来实现这个动态的需求——利用时间戳来模拟动态的数据。
代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
# -*- coding:utf-8 -*-
import time
import socket

def index():
    with open('index.html','r',encoding='utf-8')as f:
        data = f.read()
        str_now = str(time.time())
        # 替换源文件中的内容
        data = data.replace('123',str_now)
        # 注意返回bytes类型的数据
        return bytes(data,encoding='utf-8')


def home():
    with open('home.html','r',encoding='utf-8')as f:
        data = f.read()
        str_now = str(time.time())
        # 替换源文件中的内容
        data = data.replace('456',str_now)
        #注意返回bytes类型的数据
        return bytes(data,encoding='utf-8')

if __name__ == '__main__':
    opt_lst = [
        ('/index',index),
        ('/home',home),
    ]

    server = socket.socket()
    server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
    server.bind(('127.0.0.1',8765))
    server.listen()
    while 1:
        conn,addr = server.accept()
        msg = conn.recv(65105).decode('utf-8')
        # print(msg)
        # 记得先给浏览器发送响应协议
        conn.sendall(b'HTTP/1.1 200 OK \r\n\r\n')
        # 通过请求体的数据筛选出path
        path = msg.split('\r\n\r\n')[0].split()[1]
        print(path)
        # for...else
        for i in opt_lst:
            if i[0] == path:
                content = i[1]()
                # 一定要记得break，不让else中的内容执行！
                break
        else:
            content = b'404 Not Found'
        conn.sendall(content)
        conn.close()

我们需要在index页面中加入这个标签：<h2>123</h2>，在home页面中加入下面的标签：<h2>456</h2>，这样的话可以用当前的时间戳代替页面中对应的字符串，实现一下动态的效果 - -！
最后我们在浏览器中输入127.0.0.1:8765/index与127.0.0.1:8765/home并不断刷新页面就可以看到动态的效果了！

wsgiref版web服务

经过上面的讲解与代码实现，大家肯定感受到了，对于一个web应用来说，浏览器作为客户端是已经成型的了，我们需要自己去实现一个web服务端来处理浏览器的请求并返回正确的响应！
而接下来要介绍的wsgiref是世界上最nice的框架——Django（个人认为- -!）内置的一个web服务端，它的作用就是将浏览器的请求进行封装——所有的请求信息都封装到了request对象中！使用request.path就能获取到用户这次请求的路径，request.method就能获取到本次用户请求的请求方式(get还是post)等，使用wsgiref模块极大的简化了我们写web应用的工作！
对于web后端开发者来说，有了这样的一个wen服务端模块我们不用再去过度的关注浏览器中纷繁复杂的请求信息与厚重的HTTP协议规范了——这样可以将绝大多数的时间放在业务逻辑的处理上！
其实wsgiref只是基于WSGI协议下的一个性能比较低的web服务端，实际生产中部署Django项目的时候我们都会选择性能更好的Uwsgi模块，当然个人调试的时候wsgiref是足够了的。
关于WSGI协议有兴趣的老铁可以参考这篇文章简单看看：Python进阶:何为WSGI协议

利用wsgiref实现一个简单的web服务端程序

接下来我们使用Python的wsgiref模块实现一个简单的web server程序：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
from wsgiref.simple_server import make_server

# wsgiref本身就是个web框架，提供了一些固定的功能
# 请求和响应信息的封装，不需要我们自己写原生的socket了也不需要我们自己来完成请求信息的提取，用起来很方便
def application(environ,start_response):
    '''
    environ:是全部加工好的请求信息，加工成了一个字典，通过字典取值的方式就能拿到很多你想要拿到的信息
    start_response: 帮你封装响应信息的（响应行和响应头），注意下面的参数
    '''
    #200 OK必须得有~后面的两个键值对可以不加~具体看需求
    start_response('200 OK',[('Content-Type','text/html'),('k1','v1')])
    
    print(environ)
    ##输入地址127.0.0.1:8080，这个打印的是'/',输入的是127.0.0.1:8080/index，打印结果是'/index'
    print(environ['PATH_INFO'])
    #注意最后return的是：列表里面是bytes类型的数据！
    return [b'<h1>Hello Web</h1>']

if __name__ == '__main__':
    http_obj = make_server('127.0.0.1',8080,application)

    print('Serving HTTP on port 8080...')
    #开始监听HTTP请求
    http_obj.serve_forever()

启动程序后，在浏览器中输入http://127.0.0.1:8080就可以看到响应的字符串了：

1
Hello Web

关于wsgiref的深入理解建议大家看这篇文章：wsgiref 源码解析

结束语

由于篇幅有限，本文只带大家介绍一下web程序的流程以及服务端是如何处理浏览器请求并将响应正确的返回给浏览器端的，并且最后引出了Python自带的一个web服务端模块——wsgiref。
下一篇文章将利用wsgiref模块实现一个简单的web框架，带大家深入理解web框架的本质，敬请期待！

]]> <p>本文先用一个实例详细讲解了web请求与响应的具体过程并说明了web应用的本质，然后带大家由浅入深地手写了几个不同需求下的web服务端程序，帮助大家从底层理解服务端对web请求的处理过程以及web服务的运行原理，最后介绍了如何使用Python的wsgiref模块实现web请求与响应的处理。 optparse模块解析命令行参数的说明及优化 http://yoursite.com/2019/12/22/optparse模块解析命令行参数的说明及优化/ 2019-12-22T14:13:01.000Z 2019-12-22T14:41:07.426Z 关于“解析命令行参数”的方法我们一般都会用到sys.argv跟optparse模块。关于sys.argv，网上有一篇非常优秀的博客已经介绍的很详细了，大家可以去这里参考：https://www.cnblogs.com/aland-1415/p/6613449.html。这里为大家介绍一个比sys.argv更强大的optparse模块。
这里说一句题外话，点开optparse的源码，第一行注释是这样的：A powerful, extensible, and easy-to-use option parser，是否感受到了作者强有力的……
说回正题，当我们要利用server与client进行FTP文件传输的时候，在client端往往需要输入诸如 -s 10.10.10.1 -p 9001 这样的信息，当然我们不能控制用户的输入，如果用户随意的输入错误的命令，比如不写IP地址，只是写-s -p 9001，或者只写-s -p。我们如果还用sys.argv获取参数的话需要做很多麻烦的逻辑判断，这给我们开发程序带来了很大的不便。
但是如果我们利用optparse会十分便捷的解决这样的问题。

optparse介绍

optparse的用法如下
1
2
3
4
5
6
import optparse
parser = optparse.OptionParser()
parser.add_option("-s", "--server", dest="server", help="ftp server ip_address")
parser.add_option("-P", "--port", type="int", dest="port", help="ftp server port")
parser.add_option("-u", "--username", dest="username", help="username info")
parser.add_option("-p", "--password", dest="password", help="password info")

首先import optparse类，然后创建optparse对象parser，再使用add_option()来定义命令行参数，最后使用parse_args()来解析命令行。

举例说明

我们先新建一个test.py文件，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import optparse

class Wang_opt:

    def __init__(self):
        #初始化
        parser = optparse.OptionParser()
        parser.add_option("-s", "--server", dest="server", help="ftp server ip_address")
        parser.add_option("-P", "--port", type="int", dest="port", help="ftp server port")
        parser.add_option("-u", "--username", dest="username", help="username info")
        parser.add_option("-p", "--password", dest="password", help="password info")
        #解析参数
        self.options, self.args = parser.parse_args()
        print(self.options,self.args)


if __name__ == '__main__':
    whw_opt = Wang_opt()

然后在test.py文件的目录下运行python test.py，后面不跟任何参数，看看效果：
1
运行的结果一个是”字典”，里面存放的是我们需要的信息，后面有一个“空列表”，我们再试试加上符合条件的参数以及不符合条件的参数：
2
这就说明，”字典”中存放的是我们需要的信息，如果用户没有输入默认设置为None；而“列表”’中存放的是“错误”信息。再返回头看看源代码，其实这个”字典”就是上面的self.options变量，“列表”就是self.args。optparse模块解析的结果就是“我们想得到的信息”以及“用户误操作的输入信息”——的确很强大！
当然，如果用户不知道他需要输入什么命令，我们可以在后面输入 -h，寻求帮助：
3
其实大家可以对照着源代码，这些信息的关键字都是我们在add_option()方法中设置的——嗯，确实是A powerful, extensible, and easy-to-use option parser

重点说明

关于得到的“字典”与“列表”的说明

其实我们解析得到的参数self.options与self.args并不是真正意义上的字典与列表，只是“字典与列表的形象”而已！实际上，这两个参数是对象，我们可以进行如下验证，在程序最后打印：

1
print(whw_opt.options.server)

4
我们可以看到：用操作符‘.’可以取得server的值 0.0.0.0。
但是，我们如果利用字典的key-value的取值方式会报错：
5

一个小优化：

当然，再厉害的工具也必然会有缺点。如果要求用户必须有输入的话，我们可以这样来优化一下程序：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import optparse

class Wang_opt:

    def __init__(self):
        #初始化
        parser = optparse.OptionParser()
        parser.add_option("-s", "--server", dest="server", help="ftp server ip_address")
        parser.add_option("-P", "--port", type="int", dest="port", help="ftp server port")
        parser.add_option("-u", "--username", dest="username", help="username info")
        parser.add_option("-p", "--password", dest="password", help="password info")
        #解析参数
        self.options, self.args = parser.parse_args()
        print(self.options,self.args)

    def verification(self):
        if not self.options.server or not self.options.port:
            exit('ERROR!must support server and port parameters!')


if __name__ == '__main__':
    whw_opt = Wang_opt()
    whw_opt.verification()

效果如下：
6

]]> <p>关于“解析命令行参数”的方法我们一般都会用到sys.argv跟optparse模块。 tornado入门系列 http://yoursite.com/2019/12/17/tornado入门系列/ 2019-12-17T14:23:03.000Z 2020-02-09T10:36:55.195Z 本文是自己初学tornado框架的时候做的学习笔记，里面的代码与实践都是亲测有效的，希望能帮到tornado入门的同学。
所有笔记在我的博客园：tornado入门系列

]]> <p>本文是自己初学tornado框架的时候做的学习笔记，里面的代码与实践都是亲测有效的，希望能帮到tornado入门的同学。 基于tornado实现jwt认证 http://yoursite.com/2019/12/08/基于tornado实现jwt认证md/ 2019-12-08T13:12:02.000Z 2019-12-08T14:24:26.184Z 本文将使用tornado框架实现jwt认证并对其中的关键点进行讲解。

项目地址

https://github.com/Wanghongw/jwtDemos
实现的思路：用户先进行登陆认证，认证成功后生成token值（实际中可以将token保存在本地或者redis缓存中，本文为了方便直接打印在浏览器上，下一次请求直接复制粘贴到get请求的参数上或者放在Authorization头里），用户在访问需要进行token校验的url时带上之前生成的token的值让服务器进行校验，如果校验成功则返回正常的响应，否则返回错误信息。

基于tornado实现jwt

项目目录结构

1
2
3
4
5
6
7
8
├── app.py
├── handlers
│   ├── base_handler.py
│   └── views.py
├── templates
│   └── login.html
└── utils
    └── jwt_auth.py
脚本说明
  • utils中的jwt_auth.py文件是生成与校验token的脚本
  • handlers中的base_handler.py中的基类用于预定制与进行token的校验
    • 支持用户通过url传参或者使用Authorization请求头两种方式传递token
    • 特别注意：这两个校验方式同一时间只能使用一个，不可以同时使用

      过程讲解

1.用户先在浏览器中访问根目录：127.0.0.1:9898/v1，根据设计会自动分发到登陆页面
2.在登陆页面输入用户名（whw）密码（666），点击提交
3.系统自动生成token值，如：

1
"eyJ0eXAiOiJqd3QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VybmFtZSI6IndodyIsImV4cCI6MTU3NTgxNTM1MH0.mFW0ktlxnjqiu2Bf2UOEw9sxxS8eb61xcM0oCw1CQYA"

4.如果选择url传参的方式传递token，在浏览器的地址栏输入：

1
http://127.0.0.1:9898/v1/order/?token="eyJ0eXAiOiJqd3QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VybmFtZSI6IndodyIsImV4cCI6MTU3NTgxNTM1MH0.mFW0ktlxnjqiu2Bf2UOEw9sxxS8eb61xcM0oCw1CQYA"

这样就可以正常访问订单列表了。
5.如果选择Authorization请求头的方法传递token，我这里使用postman工具模拟，注意请求头后面的value的值，形式是 jwt token值：
jwt2

基类中使用prepare方法实现token校验

关于token的生成这里就不介绍了，可以在代码中找登陆那部分的逻辑。介绍一下token的校验：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
# -*- coding:utf-8 -*-
import re
import json

import tornado.web

from utils import jwt_auth


# 进行预设 继承tornado的RequestHandler
class BaseHandler(tornado.web.RequestHandler):

    def prepare(self):
        super(BaseHandler, self).prepare()

    def set_default_headers(self):
        super().set_default_headers()


# 进行token校验，继承上面的BaseHandler
class TokenHandler(BaseHandler):

    def prepare(self):
        ### 通过url传递token ###
        """
        # print(self.request.uri)
        # print(self.request.uri.get("token"))# /order?token=666
        # print(self.request.arguments)# {'token': [b'666']}
        ret = self.request.arguments.get("token","")
        # print(ret,type(ret[0])) # b'666' bytes
        # 最终结果
        # print(ret[0].decode("utf-8"))
        token = ret[0].decode("utf-8")
        result = (jwt_auth.parse_payload(token))
        if not result["status"]:
            self.token_passed = False
        else:
            self.token_passed = True
        self.token_msg = json.dumps(result, ensure_ascii=False)
        """
        ### 通过Authorization请求头传递token ###
        head = self.request.headers
        authorization = head.get("Authorization","")
        auth = authorization.split()
        if not auth:
            self.token_passed = False
            result = {'error': '未获取到Authorization请求头', 'status': False}
            self.token_msg = json.dumps(result, ensure_ascii=False)
            return
        if auth[0].lower() != 'jwt':
            self.token_passed = False
            result = {'error': 'Authorization请求头中认证方式错误', 'status': False}
            self.token_msg = json.dumps(result, ensure_ascii=False)
            return
        if len(auth) == 1:
            self.token_passed = False
            result = {'error': "非法Authorization请求头", 'status': False}
            self.token_msg = json.dumps(result, ensure_ascii=False)
            return
        elif len(auth) > 2:
            self.token_passed = False
            result = {'error': "非法Authorization请求头", 'status': False}
            self.token_msg = json.dumps(result, ensure_ascii=False)
            return
        token = auth[1]
        result = jwt_auth.parse_payload(token)
        if not result["status"]:
            self.token_passed = False
        else:
            self.token_passed = True
        self.token_msg = json.dumps(result, ensure_ascii=False)

在写tornado项目时都会先创建基类，在基类中做一下预定制。本demo也一样，我在TokenHandler中的prepare方法里做了token的认证：
对于登陆逻辑不需要token认证，继承BaseHandler；
对于其他需要token认证的视图，继承TokenHandler。

views.py中子视图类的写法如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
# -*- coding:utf-8 -*-
import json

import tornado.web
from tornado.escape import json_encode

from utils import jwt_auth
from . import base_handler


# 用于生成token的登陆逻辑继承BaseHandler！
class MainHandler(base_handler.BaseHandler):

    def get(self,*args,**kwargs):
        self.render("login.html")

    def post(self, *args, **kwargs):
        err_dic = {"status":False,"error":"用户名或密码错误"}

        name = self.get_argument("username")
        pwd = self.get_argument("password")
        if name == "whw" and pwd == "666":
            # 用户名密码正确 给用户生成token并返回
            token = jwt_auth.create_token({"username":"whw"})
            self.write(json_encode(token))
        else:
            ret = json.dumps(err_dic,ensure_ascii=False)
            self.write(ret)


# 其他需要jwt校验的继承TokenHandler！
class OrderHandler(base_handler.TokenHandler):

    def get(self):
        if self.token_passed:
            self.write("<h1>订单列表</h1>")
            self.write(self.token_msg)
        else:
            self.write(self.token_msg)

    def post(self, *args, **kwargs):
        if self.token_passed:
            self.write("添加订单")
            self.write(self.token_msg)
        else:
            self.write(self.token_msg)

    def put(self, *args, **kwargs):
        if self.token_passed:
            self.write("修改订单")
            self.write(self.token_msg)
        else:
            self.write(self.token_msg)

    def delete(self, *args, **kwargs):
        if self.token_passed:
            self.write("删除订单")
            self.write(self.token_msg)
        else:
            self.write(self.token_msg)
]]> <p>本文将使用tornado框架实现jwt认证并对其中的关键点进行讲解。 jwt的多种实现方式 http://yoursite.com/2019/11/03/jwt的多种实现方式/ 2019-11-03T14:12:02.000Z 2019-11-23T09:22:43.409Z 本文将使用多种框架实现jwt认证并对每种方式进行讲解。

项目地址

https://github.com/Wanghongw/jwtDemos
实现的思路：用户先进行登陆认证，认证成功后生成token值（实际中可以将token保存在本地或者缓存中，本文为了方便直接打印在浏览器上，下一次请求直接复制粘贴到get请求的参数上或者Authorization头里），用户在访问需要进行token校验的url时带上之前生成的token的值让服务器进行校验，如果校验成功则返回正常的响应，否则返回错误信息。

基于django实现jwt

项目目录结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
jwtDjangoDemo
├── api
│   ├── __init__.py
│   ├── admin.py
│   ├── apps.py
│   ├── migrations
│   │   ├── __init__.py
│   ├── models.py
│   ├── tests.py
│   └── views.py
├── db.sqlite3
├── jwtDjangoDemo
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
├── manage.py
├── middlewares
│   └── jwt.py
├── templates
│   └── login.html
└── utils
    └── jwt_auth.py
脚本说明
  • utils中的jet_auth.py文件是生成与校验token的脚本
  • middlewares中的jwt.py文件是中间件进行校验的脚本
    • 支持用户通过url传参或者使用Authorization请求头两种方式传递token
    • 特别注意：这两个中间件同一时间只能使用一个，不可以同时注册

过程讲解

1.用户先在浏览器中访问根目录：127.0.0.1:8001，根据设计会自动分发到登陆页面
2.在登陆页面输入用户名（whw）密码（666），点击提交
3.系统自动生成token值，如：

1
{"status": true, "token": "eyJ0eXAiOiJqd3QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VybmFtZSI6IndodyIsImV4cCI6MTU3NDQ5NTU5Nn0.DzS1oMBK967KS3ZUUvvF5RKlf3B9cOPL3eXLNpF5wMY"}

4.如果选择url传参的方式传递token，在浏览器的地址栏输入：

1
http://127.0.0.1:8001/order/?token=eyJ0eXAiOiJqd3QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VybmFtZSI6IndodyIsImV4cCI6MTU3NDQ5NTU5Nn0.DzS1oMBK967KS3ZUUvvF5RKlf3B9cOPL3eXLNpF5wMY

这样就可以正常访问订单列表了。
5.如果选择Authorization请求头的方法传递token，我这里使用postman工具模拟，注意请求头后面的value的值，形式是 jwt token值：
jwt2

关于生成加密token与token的解密的方法详见上一篇博客
中间件中的校验

这里给出中间件的写法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
# -*- coding:utf-8 -*-
import re
from django.utils.deprecation import MiddlewareMixin
from django.http import JsonResponse
from utils.jwt_auth import parse_payload
#   白名单
WHITE_LIST = ["/admin/.*","/login/","/"]
class JwtQueryParamMiddleware(MiddlewareMixin):
    """
    用户需要在url中通过参数进行传输token，例如：
    127.0.0.1:8001/order?token=eyJ0eXAiOiJqd3QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VybmFtZSI6IndodyIsImV4cCI6MTU3NDQ5MTQ0MX0.K-k40u6XCvjDiYjhyfIqKsbrN4DCYkytqmdPHmBl9k0
    """
    def process_request(self, request):
        print(request.path_info)
        # 白名单放行
        for i in WHITE_LIST:
            if re.search(request.path_info,i):
                return
        # 校验非登录页面的get请求
        token = request.GET.get('token')
        result = parse_payload(token)
        if not result['status']:
            return JsonResponse(result,json_dumps_params={'ensure_ascii':False})
        request.user_info = result['data']
        return
class JwtAuthorizationMiddleware(MiddlewareMixin):
    """
    用户需要通过请求头的方式来进行传输token，例如（注意必须写成下面这种格式）：
    Authorization:jwt eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE1NzM1NTU1NzksInVzZXJuYW1lIjoid3VwZWlxaSIsInVzZXJfaWQiOjF9.xj-7qSts6Yg5Ui55-aUOHJS4KSaeLq5weXMui2IIEJU
    """
    def process_request(self, request):
        # 白名单放行
        for i in WHITE_LIST:
            if re.search(request.path_info, i):
                return
        # 非登录页面需要校验token
        authorization = request.META.get('HTTP_AUTHORIZATION', '')
        auth = authorization.split()
        if not auth:
            return JsonResponse({'error': '未获取到Authorization请求头', 'status': False})
        if auth[0].lower() != 'jwt':
            return JsonResponse({'error': 'Authorization请求头中认证方式错误', 'status': False})
        if len(auth) == 1:
            return JsonResponse({'error': "非法Authorization请求头", 'status': False})
        elif len(auth) > 2:
            return JsonResponse({'error': "非法Authorization请求头", 'status': False})
        token = auth[1]
        result = parse_payload(token)
        if not result['status']:
            return JsonResponse(result)
        request.user_info = result['data']

基于DRF实现jwt

此示例在drf的认证组件中对token进行校验，内部编写了两个认证组件来支持用户通过两种方式传递token。

  • url传参
  • Authorization请求头

    过程简介

1.在浏览器中访问：http://127.0.0.1:8002/api/v1/login/进入登陆页面
2.输入用户名（whw）密码（666）
3.生成token的值：

1
2
3
4
{
    "status": true,
    "token": "eyJ0eXAiOiJqd3QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VybmFtZSI6IndodyIsImV4cCI6MTU3NDQ5ODczNX0.fDs0s9AryVMKIXOKLidsE3MiC4d8Dybtm5384fou83c"
}

4.访问order：http://127.0.0.1:8002/api/v1/order/?token=eyJ0eXAiOiJqd3QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VybmFtZSI6IndodyIsImV4cCI6MTU3NDQ5ODczNX0.fDs0s9AryVMKIXOKLidsE3MiC4d8Dybtm5384fou83c
此时可以看到正确的响应：

1
2
3
{
    "data": "订单列表"
}

5.使用Authorization请求头的方式与上面django的方法一致，这里就不再多余说明了，结果如下：
jwt3

相关代码

认证类的写法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from rest_framework.authentication import BaseAuthentication
from rest_framework import exceptions
from utils.jwt_auth import parse_payload
class JwtQueryParamAuthentication(BaseAuthentication):
    """
    用户需要在url中通过参数进行传输token，例如：
    http://127.0.0.1:8002/api/v1/order?token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE1NzM1NTU1NzksInVzZXJuYW1lIjoid3VwZWlxaSIsInVzZXJfaWQiOjF9.xj-7qSts6Yg5Ui55-aUOHJS4KSaeLq5weXMui2IIEJU
    """
    def authenticate(self, request):
        token = request.query_params.get('token')
        payload = parse_payload(token)
        if not payload['status']:
            raise exceptions.AuthenticationFailed(payload)
        # 如果想要request.user等于用户对象，此处可以根据payload去数据库中获取用户对象。
        return (payload, token)
class JwtAuthorizationAuthentication(BaseAuthentication):
    """
    用户需要通过请求头的方式来进行传输token，例如：
    Authorization:jwt eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE1NzM1NTU1NzksInVzZXJuYW1lIjoid3VwZWlxaSIsInVzZXJfaWQiOjF9.xj-7qSts6Yg5Ui55-aUOHJS4KSaeLq5weXMui2IIEJU
    """
    def authenticate(self, request):
        # 非登录页面需要校验token
        authorization = request.META.get('HTTP_AUTHORIZATION', '')
        auth = authorization.split()
        if not auth:
            raise exceptions.AuthenticationFailed({'error': '未获取到Authorization请求头', 'status': False})
        if auth[0].lower() != 'jwt':
            raise exceptions.AuthenticationFailed({'error': 'Authorization请求头中认证方式错误', 'status': False})
        if len(auth) == 1:
            raise exceptions.AuthenticationFailed({'error': "非法Authorization请求头", 'status': False})
        elif len(auth) > 2:
            raise exceptions.AuthenticationFailed({'error': "非法Authorization请求头", 'status': False})
        token = auth[1]
        result = parse_payload(token)
        if not result['status']:
            raise exceptions.AuthenticationFailed(result)
        # 如果想要request.user等于用户对象，此处可以根据payload去数据库中获取用户对象。
        return (result, token)
视图类的写法

直接注册认证类就好了：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
from rest_framework.views import APIView
from rest_framework.response import Response
from utils.jwt_auth import create_token
from extensions.auth import JwtQueryParamAuthentication, JwtAuthorizationAuthentication
class LoginView(APIView):
    def post(self, request, *args, **kwargs):
        """ 用户登录 """
        user = request.POST.get('username')
        pwd = request.POST.get('password')
        # 检测用户和密码是否正确，此处可以在数据进行校验。
        if user == 'wupeiqi' and pwd == '123':
            # 用户名和密码正确，给用户生成token并返回
            token = create_token({'username': 'wupeiqi'})
            return Response({'status': True, 'token': token})
        return Response({'status': False, 'error': '用户名或密码错误'})
class OrderView(APIView):
    # 通过url传递token
    authentication_classes = [JwtQueryParamAuthentication, ]
    # 通过Authorization请求头传递token
    # authentication_classes = [JwtAuthorizationAuthentication, ]
    def get(self, request, *args, **kwargs):
        print(request.user, request.auth)
        return Response({'data': '订单列表'})
    def post(self, request, *args, **kwargs):
        print(request.user, request.auth)
        return Response({'data': '添加订单'})
    def put(self, request, *args, **kwargs):
        print(request.user, request.auth)
        return Response({'data': '修改订单'})
    def delete(self, request, *args, **kwargs):
        print(request.user, request.auth)
        return Response({'data': '删除订单'})

基于Flask实现jwt

Flask的实现方式类似于Django中间件的实现方式，使用装饰器before_request，在路由分发之前处理一下请求，生成与校验token的代码与之前一样，Flask项目的代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
# -*- coding:utf-8 -*-
from flask import Flask, request, jsonify, render_template, g
from utils.jwt_auth import create_token, parse_payload
app = Flask(__name__)
# 通过url传递token
@app.before_request
def jwt_query_params_auth():
    if request.path == '/login/':
        return
    token = request.args.get('token')
    result = parse_payload(token)
    if not result['status']:
        return jsonify(result)
    g.user_info = result['data']
# 通过Authorization请求头传递token
"""
@app.before_request
def jwt_authorization_auth():
    if request.path == '/login/':
        return
    authorization = request.headers.get('Authorization', '')
    auth = authorization.split()
    if not auth:
        return jsonify({'error': '未获取到Authorization请求头', 'status': False})
    if auth[0].lower() != 'jwt':
        return jsonify({'error': 'Authorization请求头中认证方式错误', 'status': False})
    if len(auth) == 1:
        return jsonify({'error': "非法Authorization请求头", 'status': False})
    elif len(auth) > 2:
        return jsonify({'error': "非法Authorization请求头", 'status': False})
    token = auth[1]
    result = parse_payload(token)
    if not result['status']:
        return jsonify(result)
    g.user_info = result['data']
"""
@app.route('/login/', methods=['GET','POST'])
def login():
    # GET请求返回登陆页面
    if request.method == "GET":
        return render_template("login.html")
    # POST 方法 认证
    user = request.form.get('username')
    pwd = request.form.get('password')
    # 检测用户和密码是否正确，此处可以在数据进行校验。
    if user == 'whw' and pwd == '666':
        # 用户名和密码正确，给用户生成token并返回
        token = create_token({'username': 'wupeiqi'})
        return jsonify({'status': True, 'token': token})
    return jsonify({'status': False, 'error': '用户名或密码错误'})
@app.route('/order/', methods=['GET', "POST", "PUT", "DELETE"])
def order():
    print(g.user_info)
    if request.method == 'GET':
        return "订单列表"
    return "订单信息"
if __name__ == '__main__':
    app.run()

参考文章

https://www.cnblogs.com/wupeiqi/p/11854573.html

]]> <p>本文将使用多种框架实现jwt认证并对每种方式进行讲解。 从用户认证到jwt的说明 http://yoursite.com/2019/10/30/从用户认证到jwt的说明/ 2019-10-30T13:22:32.000Z 2019-11-23T09:38:17.249Z Json Web Token (JWT) 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准(RFC 7519)。该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其它业务逻辑所必须的声明信息，该token也可直接被用于认证，也可被加密。目前，jwt广泛应用在系统的用户认证方面，特别是现在前后端分离项目。

session与token

关于用户认证肯定避不开session与token这两个技术点，因此在讨论jwt前我们很有必要谈一谈基于session与token的认证模式。

传统的session认证

我们知道，http协议本身是一种无状态的协议，而这就意味着如果用户向我们的应用提供了用户名和密码来进行用户认证，那么下一次请求时，用户还要再一次进行用户认证才行，因为根据http协议，我们并不能知道是哪个用户发出的请求，所以为了让我们的应用能识别是哪个用户发出的请求，我们只能在服务器存储一份用户登录的信息，这份登录信息会在响应时传递给浏览器，告诉其保存为cookie,以便下次请求时发送给我们的应用，这样我们的应用就能识别请求来自哪个用户了,这就是传统的基于session认证：

1
2
3
4
5
1、用户向服务器发送用户名和密码。
2、服务器验证通过后，在当前对话（session）里面保存相关数据，比如用户角色、登录时间等等。
3、服务器向用户返回一个 session_id，写入用户的 Cookie。
4、用户随后的每一次请求，都会通过 Cookie，将 session_id 传回服务器。
5、服务器收到 session_id，找到前期保存的数据，由此得知用户的身份。

但是这种基于session的认证使应用本身很难得到扩展，随着不同客户端用户的增加，独立的服务器已无法承载更多的用户，而这时候基于session认证应用的问题就会暴露出来.

基于session认证所显露的问题

Session: 每个用户经过我们的应用认证之后，我们的应用都要在服务端做一次记录，以方便用户下次请求的鉴别，通常而言session都是保存在内存中，而随着认证用户的增多，服务端的开销会明显增大。
扩展性: 用户认证之后，服务端做认证记录，如果认证的记录被保存在内存中的话，这意味着用户下次请求还必须要请求在这台服务器上,这样才能拿到授权的资源，这样在分布式的应用上，相应的限制了负载均衡器的能力。这也意味着限制了应用的扩展能力。
CSRF: 因为是基于cookie来进行用户识别的, cookie如果被截获，用户就会很容易受到跨站请求伪造的攻击。

基于token的校验机制

基于token的鉴权机制类似于http协议也是无状态的，它不需要在服务端去保留用户的认证信息或者会话信息。这就意味着基于token认证机制的应用不需要去考虑用户在哪一台服务器登录了，这就为应用的扩展提供了便利。
基于token的认证流程如下：
jwt1
其实jwt也是基于这种流程实现的，只不过jwt与传统的token方式有一些区别。

传统的token方式与jwt的差异

传统的token方式

用户登录成功后，服务端生成一个随机token给用户，并且在服务端(数据库或缓存)中保存一份token，以后用户再来访问时需携带token，服务端接收到token之后，去数据库或缓存中进行校验token的是否超时、是否合法。

jwt方式
用户登录成功后，服务端通过jwt生成一个随机token给用户（服务端无需保留token），以后用户再来访问时需携带token，服务端接收到token之后，通过jwt对token进行校验是否超时、是否合法。

jwt的说明

jwt的原理

jwt的原理是，服务器认证以后，生成一个 JSON 对象，发回给用户，就像下面这样。

1
2
3
4
5
{
  "姓名": "whw",
  "角色": "火影",
  "到期时间": "9999年09月09日09点09分"
}

以后，用户与服务端通信的时候，都要发回这个 JSON 对象。服务器完全只靠这个对象认定用户身份。为了防止用户篡改数据，服务器在生成这个对象的时候，会加上签名。
特别注意：服务器不保存任何 session 数据，也就是说，服务器变成无状态了，这样比较容易实现扩展。

jwt的数据结构

实际的jwt大概像这样：

1
xxx.xxxx.xx

它是一个很长的字符串，中间用点（.）分隔成三个部分。
jwt的三部分依次如下：

  • 头部（Header）
  • 负载（Payload）
  • 签名（Signature）
    写成一行就是下面这样：
    1
    Header.Payload.Signature
这三部分的生成规则如下：

  • 第一段Header部分，固定包含算法和token类型，对此json进行base64url加密：

    1
    2
    3
    4
    {
      "alg": "HS256",
      "typ": "JWT"
    }

  • 第二段Payload部分，包含一些数据，对此json进行base64url加密：

    1
    2
    3
    4
    5
    6
    {
      "sub": "1234567890",
      "name": "whw",
      "iat": 1516239022
      ...
    }

  • 第三段SIGNATURE部分，把前两段的base密文通过.拼接起来，然后对其进行HS256加密，再然后对hs256密文进行base64url加密，最终得到token的第三段：

    1
    2
    3
    4
    5
    6
    base64url(
        HMACSHA256(
          base64UrlEncode(header) + "." + base64UrlEncode(payload),
          your-256-bit-secret (秘钥加盐)
        )
    )

最后将三段字符串通过.拼接起来就生成了jwt的token。
注意：base64url加密是先做base64加密，然后再将 - 替代 + 及 _ 替代 / 。

代码实现token加密

  • 先安装jwt模块

    1
    pip3 install pyjwt

  • 代码实现

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    # -*- coding:utf-8 -*-
    import datetime

    import jwt
    from jwt import exceptions


    SALT = "huoyingwhw666"

    def create_token():
        # 构造header
        headers = {
            "typ":"jwt",
            "alg":"HS256",
        }
        # 构造payload
        payload = {
            "id":1,
            "name":"whw",
            "exp":datetime.datetime.now() + datetime.timedelta(hours=1) # 超时时间
        }

        ret = jwt.encode(headers=headers,payload=payload,key=SALT,algorithm="HS256").decode("utf-8")
        return ret

    if __name__ == '__main__':
        token = create_token()
        print(token)

  • 结果如下：

    1
    eyJ0eXAiOiJqd3QiLCJhbGciOiJIUzI1NiJ9.eyJpZCI6MSwibmFtZSI6IndodyIsImV4cCI6MTU3NDUxNTk5MX0.AkUg9tnDhVX5iSUYXB2arGDlm9VOpKD1LAqpXwL3Ka8

jwt校验token

一般在认证成功后，把jwt生成的token返回给用户，以后用户再次访问时候需要携带token，此时jwt需要对token进行超时及合法性校验。

校验过程

获取token之后，会按照以下步骤进行校验：

  • 将token分割成 header_segment、payload_segment、crypto_segment 三部分
  • 对第一部分header_segment进行base64url解密，得到header
  • 对第二部分payload_segment进行base64url解密，得到payload
  • 对第三部分crypto_segment进行base64url解密，得到signature
  • 对第三部分signature部分数据进行合法性校验
    • 拼接前两段密文，即：signing_input
    • 从第一段明文中获取加密算法，默认：HS256
    • 使用 算法+盐 对signing_input 进行加密，将得到的结果和signature密文进行比较。

      代码实现

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      # -*- coding:utf-8 -*-
      import jwt
      import datetime
      from jwt import exceptions


      SALT = "huoyingwhw666"

      # 根据token获取payload的值
      def get_payload(token):
          try:
              # 从token中获取payload「不校验合法性」
              """
              unverified_payload = jwt.decode(token,None,False)
              print(unverified_payload)
              """
              # 从token中获取payload「校验合法性」
              verified_payload = jwt.decode(token,SALT,True)
              return {"status":True,"msg":"认证成功","payload":verified_payload}
          except exceptions.ExpiredSignatureError:
              return {"status":False,"msg":"token已失效"}
          except jwt.DecodeError:
              return {"status": False, "msg": "token认证失败"}
          except jwt.InvalidTokenError:
              return {"status": False, "msg": "非法的token"}

      if __name__ == '__main__':
          # 使用上一段代码生成的token值
          token = "eyJ0eXAiOiJqd3QiLCJhbGciOiJIUzI1NiJ9.eyJpZCI6MSwibmFtZSI6IndodyIsImV4cCI6MTU3NDUxNTk5MX0.AkUg9tnDhVX5iSUYXB2arGDlm9VOpKD1LAqpXwL3Ka8"
          payload = get_payload(token)
          print(payload)

结果如下：

1
{'status': True, 'msg': '认证成功', 'payload': {'id': 1, 'name': 'whw', 'exp': 1574515991}}

jwt的具体实现

jwt实现的实例放在了我的github中：https://github.com/Wanghongw/jwtDemos
下一篇文章将详细讲解jwt实现的细节。

参考文章

单点登陆SSO介绍
https://www.jianshu.com/p/576dbf44b2ae
https://www.cnblogs.com/wupeiqi/p/11854573.html
http://www.ruanyifeng.com/blog/2018/07/json_web_token-tutorial.html

]]> <p>Json Web Token (JWT) 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准(RFC 7519)。该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其它业务逻辑所必须的声明信息，该token也可直接被用于认证，也可被加密。目前，jwt广泛应用在系统的用户认证方面，特别是现在前后端分离项目。 Celery介绍及在Django中的使用 http://yoursite.com/2019/10/07/Celery介绍及在Django中的使用/ 2019-10-07T11:30:22.000Z 2020-01-07T14:52:39.852Z 本文详细介绍了Celery的原理、简单使用以及在Django中的应用实例。
Celery博客我写在了博客园中，因为博客园的文本编辑器相对来说格式更加丰富，Celery这篇博客个人认为还是有很多需要重点注意的细节的，所以重要的地方都用特殊的格式标注了下来，希望对大家学习Celery以及在Django中使用Celery有所帮助！
博客链接：异步任务分发模块Celery

]]> <p>本文详细介绍了Celery的原理、简单使用以及在Django中的应用实例。 Django中contenttypes组件的使用 http://yoursite.com/2019/09/22/Django中contenttypes组件的使用/ 2019-09-22T09:21:23.000Z 2019-09-22T13:53:04.184Z contenttypes是Django内置的一个非常有用的组件，它对当前项目中所有基于Django驱动的model提供了更高层次的接口，简单点说，它可以追踪项目中所有的应用与model的对应关系并将这些关系记录在ContentType表中，每当我们创建了新的model并执行数据库迁移指令后，ContentType表中就会自动新增一条不同应用和这个应用中的model之间对应关系的记录；更重要的是，我们不仅可以使用contenttypes提供的GenericForeignKey类与GenericReleation类去避免因大量复杂的ORM查询导致的程序效率降低，而且在实际项目中使用contenttypes还会优化项目数据库表结构的设计，避免数据库中产生许多无用的数据。
本文用一个简单的业务为例详细为大家介绍一下使用contenttypes组件有何优点、组件的具体用法及其使用场景等等。

Django中的contenttypes组件

假如说，公司A的主要业务是培训青少年人工智能与机器人技术，主要分类是基础课程与高级课程，而这两个大的分类中又有其他具体的课程。每个课程根据培训周期的不同培训费用的计算方式也不一样。也许没有做过相关业务的同学还没有get到相关的点，这里我先粗略的画一下表结构，后面再详细阐述。

初版表结构设计

如果不用contenttypes，大致的表结构会这么设计：
image-20190922200038809
由上图我们可以看到基础课程与高级课程下有多个不同的子课程。
接下来看一下价格策略这张表，每个小课程（比如Python初级与Python高级）由于培训周期的不同价格是不一样的（这里只是模拟，请勿对号入座），并且PricePolicy表中journeycourse_id与seniorcourse_id是与两个课程表建立外键的字段——此时聪明的你立刻就发现问题了：初级课程的周期最多周期只有21天，而高级课程的培训周期是按月来计算的！如果这样会导致数据库中产生许多无用的空数据！
上面这个问题这是一个很典型的一张表与多张表动态的创建ForeignKey关系的问题，而要解决上面产生无用数据的问题可以选择使用Django中的contenttypes。

使用contenttypes的表结构

image-20190922202135890
详细说明如下：

  1. 新增了一个ContentType表（settings中默认注册了contenttypes组件，Django启动时会自动生成），这个表中存放了model的名称；
  2. 价格策略表中的content_type_id字段是PricePolicy表与ContentType表之间外键关联的字段；
  3. 价格策略表中的object_id字段对应的是基础课程或者高级课程中具体的子类课程的id；
  4. 在价格策略表中，我们可以根据大课程的分类content_type_id、子课程的idobject_id以及培训的周期period确定一条唯一的记录！
  5. 特别注意object_id只是一个普通的字段，它并没有与任何表建立外键关联！
    这样设计的话就不会出现上面那种空的无效数据了！

    contenttypes的具体实现

    老规矩，先上代码，后面给出具体的说明！
    项目应用中的models.py文件如下：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    from django.db import models
    from django.contrib.contenttypes.models import ContentType
    from django.contrib.contenttypes.fields import GenericForeignKey,GenericRelation

    class JuniorCourse(models.Model):
        """初级课程"""
        name = models.CharField(max_length=64,verbose_name='初级课程名称')
        course_img = models.CharField(max_length=255, verbose_name="课程缩略图")
        brief = models.TextField(verbose_name="初级课程简介", )
        
        # 不会在数据库中生成列，只是帮我们添加与查询数据用的
        # 建立GenericRelation的字段如果被删除的话，PricePolicy中对应的记录也会被删掉！
        policy_lst = GenericRelation('PricePolicy')

    class SeniorCourse(models.Model):
        """高级课程"""
        name = models.CharField(max_length=64, verbose_name='进阶级课程名称')
        course_img = models.CharField(max_length=255, verbose_name="课程缩略图")
        brief = models.TextField(verbose_name="进阶级课程简介", )

        # 不会在数据库中生成列，只是帮我们添加与查询数据用的
        # 建立GenericRelation的字段如果被删除的话，PricePolicy中对应的记录也会被删掉！
        policy_lst = GenericRelation('PricePolicy')


    class PricePolicy(models.Model):
        """价格策略——课程有效期与价格表"""
        # 与ContentType表做关联 —— 找到大的分类
        content_type = models.ForeignKey(to=ContentType,on_delete=models.CASCADE)
        # 对应"大分类中的课程的id"，用正整数表示 —— 名字必须叫object_id
        object_id = models.PositiveIntegerField()

        # 不会在数据库中生成列，只是帮我们添加与查询查询数据用的
        content_object = GenericForeignKey('content_type','object_id')

        valid_period_choices = (
            (1,'1天'),
            (3,'3天'),
            (7,'1周'),
            (14,'2周'),
            (21,'3周'),
            (30,'1个月'),
            (60,'2个月'),
            (90,'3个月'),
        )
        valid_period = models.SmallIntegerField(choices=valid_period_choices,verbose_name='课程周期')
        price = models.DecimalField(max_digits=8,decimal_places=1)

详细说明如下：
1、大家首先要注意一点：由于项目的settings.py文件中默认注册了django.contrib.contenttypes这个组件，所以我们在执行数据库迁移指令的时候，Django会自动为我们创建一张铭文django_content_type的表，存放项目应用与应用里面model对应关系：
image-20190922203753923
可以看到，最下面那三条记录就是我上面的代码执行数据库迁移指令后生成的——我的应用名叫testapp。
2、引用这张django_content_type表的方式是：

1
from django.contrib.contenttypes.models import ContentType

注意不要改这张表！我们从里面查数据就好了——基本上都是查model。
3、我们来看一下PricePolicy这个类：首先它与ContentType表建立了外键关联，content_object这个属性是GenericForeignKey类实例化的对象，参数是上面的content_type与object_id属性——这步操作不会在数据库中创建新的列，是为了方便我们后续添加与查询数据用的。我们在知道了价格策略的条件下可以根据GenericForeignKey对应的属性查到具体的课程。
4、GenericRelation写在了具体课程的类下面，我们可以它实例化的属性，拿课程对象去查询这个课程对应的价格策略都有哪些——但是要注意一点：GenericRelation对应字段的对象如果被删除的话，PricePolicy中对应的记录也会被删掉！也就是说，根据上面建立的model关系，如果我删除了一条seniorcourse中的记录，那与这条记录对应的pricepolicy中的记录也会被删除！

视图函数中的增删改查

上面介绍了在models.py中如何用contenttypes，接下来我们来看看如何在视图函数中使用它。

向价格策略表中添加数据

由于上面的models.py文件中我们在PricePolicy类中定义了content_object这个GenericForeignkey类的实例化对象，在创建数据的时候直接指定content_object就可以了：

1
2
3
4
5
6
7
8
9
10
11
12
13
# 与seniorcourse表的关系
models.PricePolicy.objects.create(
    valid_period=7,
    price=123.45,
    # 直接根据SeniorCourse对象添加
    content_object = models.SeniorCourse.objects.get(pk=2),
)
# 与juniorcourse表的关系
models.PricePolicy.objects.create(
    valid_period=3,
    price=35.66,
    # # 直接根据JuniorCourse对象添加
    content_object = models.JuniorCourse.objects.get(pk=1),

其他两张课程表直接添加数据就好了，没有任何的约束。

根据某个价格策略对象去找与它对应的表的数据

这里其实还是利用了GenericForeignKey，自动跨表查询：

1
2
3
4
5
6
7
8
9
from django.contrib.contenttypes.models import ContentType

# 在ContentType表中找到具体的表
contenttype_obj = ContentType.objects.get(model='seniorcourse')
# 找到价格策略对象
# 注意get是查询唯一对象的方法，所以给出的条件必须保证只查到一个对象！
obj=models.PricePolicy.objects.get(content_type=contenttype_obj,object_id=1,valid_period=)
    ### 直接“跨表查询”就好了
    print(obj.content_object.name)
找到某个课程相关的所有价格策略***

这个在实际中用的还是很多的！这里用到了GenericRelation，也就是上面models.py文件中定义在高级课程与初级课程类中的那两个属性。

1
2
3
4
obj = models.SeniorCourse.objects.get(pk=1)
# 注意这里必须用all()方法
    for i in obj.policy_lst.all():
        print(i.pk,i.valid_period,i.price)
课程中如果用了GenericRelation类实例化出来的对象作为属性的话，删除课程中的数据时，价格策略中与之相关的数据也会一起被删除！
1
2
# 删除了SeniorCourse中的一个课程后，PricePublic中与之相关的数据都删除了！！！
models.SeniorCourse.objects.get(pk=1).delete()

contenttypes使用小结

根据上面的介绍，其实contenttypes的使用大致分为这几步：

  1. 创建ContentType表（Django的settings中默认注册了contenttypes应用，启动时会自动生成）；
  2. 价格策略表与ContentType表建立外键关联关系；
  3. 定义GenericForeignKey属性，根据价格策略表中的记录去查询具体课程的信息或者根据课程对象创建价格策略的记录；
  4. 定义GenericRelation的属性，根据具体的课程对象在价格策略表中查找与这个课程相关的所有的价格策略；
  5. 定义了GenericRelation的属性的话需要注意：删除课程中的一条记录价格策略表中与这个课程相关的所有记录也都会被删除掉！

    contenttypes的使用场景

    在实际中，contenttypes绝大多数都用在一张表与N张表动态的创建ForeignKey关系的场景下。
    其实实际中contenttypes的使用场景还是很多的，比如评论功能：如果一个网站的文章、视频、图片等都需要加评论的话，我们可以把评论这张表与文章、图片、视频都建立向上面那样的外键关联；再拿上面的例子来说，我们可以为不同分类下的没门课程加入优惠券，优惠券这张表跟价格策略表性质一样，也需要与那两张课程表建立外键关系，此时使用contenttypes会十分高效！

    更多参考文章

    官方文档
    https://blog.csdn.net/laughing2333/article/details/53014267
    https://blog.csdn.net/weixin_42134789/article/details/80690182
]]> <p>contenttypes是Django内置的一个非常有用的组件，它对当前项目中所有基于Django驱动的model提供了更高层次的接口，简单点说，它可以追踪项目中所有的应用与model的对应关系并将这些关系记录在ContentType表中，每当我们创建了新的model并执行数据库迁移指令后，ContentType表中就会自动新增一条不同应用和这个应用中的model之间对应关系的记录；更重要的是，我们不仅可以使用contenttypes提供的<code>GenericForeignKey类</code>与<code>GenericReleation类</code>去避免因大量复杂的ORM查询导致的程序效率降低，而且在实际项目中使用contenttypes还会优化项目数据库表结构的设计，避免数据库中产生许多无用的数据。<br>本文用一个简单的业务为例详细为大家介绍一下使用contenttypes组件有何优点、组件的具体用法及其使用场景等等。 在CentOS7系统中部署Django项目 http://yoursite.com/2019/09/21/在CentOS7系统中部署Django项目/ 2019-09-21T04:23:34.000Z 2019-09-21T08:54:41.559Z 作为一名后端开发的程序员不仅要会写业务代码、解决各种BUG、优化项目性能，也应该知道如何将自己写好的项目部署到服务器中让别人去访问。
本文详细讲解了用一台安装了CentOS7.5系统的裸奔Linux机器（虚拟机）从零开始部署django项目的过程。

安装必要的工具

配置yum源

至于什么是yum源大家请自行百度，本人用的是阿里云的yum源，因此需要在裸机上配置一下：

进入yum源的目录

1
cd /etc/yum.repos.d/

查看yum源文件

1
ls -l

img11

配置阿里云yum源

1.好习惯，备份yum源

1
2
mkdir repo_bak
mv *.repo repo_bak/

2.下载阿里云repo文件

1
wget http://mirrors.aliyun.com/repo/Centos-7.repo

3.清空yum缓存并且生成新的yum缓存

1
2
yum clean all
yum makecache

4.安装软件扩展源

1
yum install -y epel-release

安装pthon3

推荐利用编译的方式安装Python3。

安装依赖环境——非常重要

1
yum install gcc patch libffi-devel python-devel  zlib-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gdbm-devel db4-devel libpcap-devel xz-devel -y

下载解压源码包

需要注意的是，Linux系统的第三方软件都约定俗成的安装在/opt目录下~因此我们需要把这个包下载到/opt目录下

1
2
cd /opt
wget https://www.python.org/ftp/python/3.6.5/Python-3.6.5.tgz

解压

1
tar -zxvf Python-3.6.5.tgz

开始编译安装

configure
进入解压出出来的Python-3.6.5目录，里面有一个绿色的可执行文件configure~
这一步一般用来生成 Makefile，为下一步的编译做准备，你可以通过在 configure 后加上参数来对安装进行控制，比如代码:

1
./configure --prefix=/opt/py365

上面的意思是将该软件安装在 /opt/py365 下面，执行文件就会安装在 /opt/py365/bin （而不是默认的 /usr/local/bin)，资源文件就会安装在 /usr/share（而不是默认的/usr/local/share）。
同时一些软件的配置文件你可以通过指定 –sys-config= 参数进行设定。有一些软件还可以加上 –with、–enable、–without、–disable 等等参数对编译加以控制，你可以通过允许 ./configure –help 察看详细的说明帮助。
——我这里没有加后面的参数，直接执行 ./configure，默认安装在了/usr/local/bin中~
make

1
make
1
2
3
4
这一步就是编译，大多数的源代码包都经过这一步进行编译（当然有些perl或python编写的软件需要调用perl或python来进行编译）。
如果 在 make 过程中出现 error ，你就要记下错误代码（注意不仅仅是最后一行），然后你可以向开发者提交 bugreport（一般在 INSTALL 里有提交地址），或者你的系统少了一些依赖库等，这些需要自己仔细研究错误代码。
make 的作用是开始进行源代码编译，以及一些功能的提供，这些功能由他的 Makefile 设置文件提供相关的功能，比如 make install 一般表示进行安装，make uninstall 是卸载，不加参数就是默认的进行源代码编译。
make 是 [Linux](http://www.icultivator.com/tag/linux) 开发套件里面自动化编译的一个控制程序，他通过借助 Makefile 里面编写的编译规范进行自动化的调用 [gcc](http://www.icultivator.com/tag/gcc) 、ld 以及运行某些需要的程序进行编译的程序。一般情况下，他所使用的 Makefile 控制代码，由 configure 这个设置脚本根据给定的参数和系统环境生成。

make install

1
make install
1
这条命令来进行安装（当然有些软件需要先运行 make check 或 make test来进行一些测试），这一步一般需要你有 root 权限（因为要向系统写入文件）

安装虚拟环境包virtualenv及管理工具virtualenvwrapper

我自己之前总结过两篇相关的博客（原创哦）：
linux下虚拟环境模块virtualenv及管理工具virtualenvwrapper的使用
windows与mac下virtualenv与Pycharm的结合使用

安装nginx

提示

nginx的安装也推荐编译安装！
由于本文用的是一个裸机，如果大家之前用yum安装了nginx，请卸载yum安装的nginx！！！

1
yum remove nginx -y

解决软件包依赖——特别重要

1
yum install gcc patch libffi-devel python-devel  zlib-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gdbm-devel db4-devel libpcap-devel xz-devel openssl openssl-devel -y

下载nginx的源码包并解压

我这里用的是淘宝的Tengine——在原始nginx上扩展了许多功能很强大
需要注意的是，Linux系统的第三方软件都约定俗成的安装在/opt目录下~因此我们需要把这个包下载到/opt目录下

1
2
cd /opt
wget http://tengine.taobao.org/download/tengine-2.3.1.tar.gz

解压tengine包：

1
tar -zxvf tengine-2.3.1.tar.gz

安装tengine

进入源码目录：

1
cd tengine-2.3.1/

里面有一个绿色的可执行文件configure
这里我们指定将tengine安装在/opt/tngx231这个目录下：

1
./configure --prefix=/opt/tngx231/

然后进行编译安装：

1
make && make install

结束后我们可以看到新生成了一个/opt/tngx321目录
安装好的nginx放在了 /opt/tngx231/sbin/ 这个目录下了~

修改环境变量让nginx命令生效

安装完成后需要每次用/opt/tngx231/sbin/ 这个目录加上nginx才能操作，很烦躁，我们可以通过修改环境变量，以后只需要执行nginx就可以启用nginx的操作了~
<1>首先确认下当前的环境变量有哪些目录： 

1
2
echo $PATH   
#/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin

<2> 编辑/etc/profile文件

1
vim /etc/profile

<3>在文件的最后一行输入 ：

1
PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:/opt/tngx231/sbin"

并 :wq 保存退出~~
<4>最后一定要记得source一下 /etc/profile 文件！

1
source /etc/profile

nginx的启停命令

在没有修改环境变量之前，我们需要进入nginx的安装目录（本文是在 /opt/tngx231/sbin/ ）这样执行：

1
2
3
./nginx #启动
./nginx -s stop #关闭
./nginx -s reload #重新加载

修改了环境变量后可以直接这样执行：

1
2
3
4
nginx #启动
nginx -t #查看nginx状态
nginx -s stop #关闭
nginx -s reload #重新加载

测试nginx的服务
安装完成后别忘了检测一下nginx的服务

1
2
netstat -tunlp |grep 80
curl -I 127.0.0.1

结果如下：
img
如果访问不了，检查selinux，iptables

1
2
3
#关防火墙
systemctl disable firewalled
setenforce 0

项目部署过程

创建虚拟环境并在虚拟环境中安装必要的包

利用virtualenvwrapper工具创建虚拟环境

1
mkvirtualenv whw_dj1

创建完虚拟环境后直接会进入这个虚拟环境。
在这个环境中安装项目需要的包，安装过程略（直接用pip安装即可），结果如下：
img
这里需要记录一下uwsgi的执行路径以及虚拟环境的目录，后面要用：
uwsgi的执行路径
特别注意：如果在虚拟环境中运行的话，后面执行uwsgi命令需要用绝对路径的时候一定是虚拟环境中的这个绝对路径！
(补充说明一点：如果虚拟环境中没有安装uwsgi模块的话会显示外部环境中的位置，因此一定要记得在虚拟环境中安装uwsgi模块!)

1
2
(whw_di1) [root@bogon opt]# which uwsgi
/root/Envs/whw_di1/bin/uwsgi

虚拟环境的目录
特别注意：如果在虚拟环境中运行的话，后面uwsgi的配置文件一定要写当前虚拟环境下的uwsgi的绝对路径！

1
2
3
(whw_di1) [root@bogon opt]# cdvirtualenv 
(whw_di1) [root@bogon whw_di1]# pwd
/root/Envs/whw_di1

项目文件settings与静态文件相关的配置

将项目传到服务器的/opt目录~进入项目的二级目录，配置一下里面的settings文件，这里只写与部署相关的配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
# 线上部署一定要记得把DEBUG改成False
DEBUG = False

# 94这个ip是我的云服务器的Ip，一般情况下是这样配置
# ALLOWED_HOSTS = ['localhost','94.191.41.167','0.0.0.0:8000','127.0.0.1' ]
# 自己测试的话直接allow所有的ip就好了
ALLOWED_HOSTS = ['*' ]

# sqllit数据库的配置
DATABASES = {
     'default': {
         'ENGINE': 'django.db.backends.sqlite3',
         'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
     }
 }

# 静态文件配置
# 第一个参数是将静态文件copy到服务器的目录的位置
STATIC_ROOT='/opt/whw_static/'
STATIC_URL = '/static/'
STATICFILES_DIRS = [
    os.path.join(BASE_DIR,'staticfiles'),
]


## mysql的配置——本文用的是sqllit，因此这个配置注释掉
#DATABASES = {
#    'default': {
#        'ENGINE': 'django.db.backends.mysql',#引擎，选mysql
#        'NAME':'whw1',#要连接的数据库，连接前需要创建好
#        'USER':'root',#连接数据库的用户名
#        'PASSWORD':'123',#连接数据库的密码
#        'HOST':'127.0.0.1',#连接主机，默认本本机
#        'PORT':3306,#端口 默认3306
#        #Django中设置数据库的严格模式
#       'OPTIONS':{
#           'init_command':"set sql_mode='STRICT_TRANS_TABLES' ",
#           }
#       }
#   }

由于uwsgi不能处理项目的静态文件，我们需要用nginx来处理，因此需要将项目的静态文件copy到STATIC_ROOT参数对应的位置：

1
python3  /opt/whw/manage.py  collectstatic

whw是我的项目的第一层目录，就是我的项目的名字。

uwsgi的配置

提醒一点：需要提前在虚拟环境中安装好uwsgi包~~

uwsgi.ini文件的配置

配置uwsgi之前需要新建一个uwsgi.ini文件。
由于每个项目对应一个uwsgi.ini文件，这里建议大家将这个文件创建在自己项目的第一层目录中：

1
2
cd /opt/whw/
touch uwsgi.ini

然后编辑这个文件

1
vim uwsgi.ini

文件中的配置如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
[uwsgi]
# Django-related settings
# the base directory (full path)
#项目的绝对路径,定位到项目的第一层
chdir = /opt/whw
# Django's wsgi file
# 找到项目第二层的wsgi文件
module = whw.wsgi
# the virtualenv (full path)
# 找到虚拟环境的绝对路径~注意最后不要加/!!!
home = /root/Envs/whw_di1
# process-related settings
# master
# 主进程
master = true
# maximum number of worker processes
# 开启uwsgi的多进程数,根据cpu核数来定义
processes = 16
# the socket (use the full path to be safe
# 基于socket链接运行项目,只有与nginx结合的时候,才使用socket形式
socket = 0.0.0.0:8000
# 当你没用nginx,调试项目的时候,使用http形式 
#http =  0.0.0.0:8000
# ... with appropriate permissions - may be needed
# chmod-socket    = 664
# clear environment on exit
vacuum = true
# 记录pid与日志的文件
pidfile=uwsgi.pid
daemonize=uwsgi.log

启动uwsgi

进入项目的第一层目录，这里有写好的uwsgi.ini文件，执行这个文件：

1
uwsgi --ini  uwsgi.ini

特别注意，这里用的都是相对路径~真正的执行命令其实是这样的：

1
/root/Envs/whw_di1/bin/uwsgi --ini /opt/whw/uwsgi.ini

——这样的执行结果是在前台运行的，我们的终端会夯住，如果关掉这个终端uwsgi的进行也会关掉，需要我们再打开一个终端进行下一步的操作~
——让uwsgi后台执行的话~只需要在命令里面加上-d参数就好了：

1
uwsgi -d --ini uwsgi.ini

nginx的配置

nginx的配置文件是 /opt/tngx231/conf/nginx.conf 。

1
2
3
# 这里需要说明一下：
如果安装的是nginx不是tengine，且没有指定安装目录，那么它的配置文件默认是 
/etc/nginx目录中的nginx.conf文件

编辑这个文件

1
vim /opt/tngx231/conf/nginx.conf

我们只配置第一个server里面的参数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
server {
        listen       80;
        server_name  localhost;
        location / {
            # 支持uwsgi的配置
            include uwsgi_params;
            # ip与端口是uwsgi服务器的ip与端口~本例二者在一个机器里因此用环回地址
            uwsgi_pass 127.0.0.1:8000;
            #root   html;
            #index  index.html index.htm;
        }
    
        # 存放静态文件的配置
        location /static{
            alias /opt/whw_static;
        }

　　　　# xxxxxxxxxxxxxxx
}

nginx配置完后启动nginx服务：

1
nginx

如果中途修改了nginx.conf的参数的话，保存完后需要重启nginx服务，记得在重启前-t一下查看nginx的状态：

1
2
3
4
5
(whw_di1) [root@bogon whw]# nginx -t
nginx: the configuration file /opt/tngx231//conf/nginx.conf syntax is ok
nginx: configuration file /opt/tngx231//conf/nginx.conf test is successful
(whw_di1) [root@bogon whw]# 
(whw_di1) [root@bogon whw]# nginx -s reload

至此，项目部署的配置就这么多了。

请求流程简介

（1）用户发起请求
（2）访问IP(或者访问域名) 请求走到nginx这一层代理
（3）nginx直接转发(uwsgi_pass)给后端django的地址
（4）django处理完毕
（5）响应给nginx
（6）nginx返回结果给浏览器界面

]]> <p>作为一名后端开发的程序员不仅要会写业务代码、解决各种BUG、优化项目性能，也应该知道如何将自己写好的项目部署到服务器中让别人去访问。<br>本文详细讲解了用一台安装了CentOS7.5系统的裸奔Linux机器（虚拟机）从零开始部署django项目的过程。 Django中的信号signal http://yoursite.com/2019/09/21/Django中的信号signal/ 2019-09-21T03:11:29.000Z 2019-09-21T08:32:19.224Z 在真实的企业生产环境中，我们会遇到各种各样的需求，比如在全局对客户端请求进行过滤，将不满足某些条件的客户端请求过滤掉，这时我们可以利用Django的中间件来实现该需求；或者，我们希望每次model的save()方法被调用后，都要写一条日志到日志文件中，而此时我们可以通过Django提供的内置信号post_save来实现，本文介绍一下Django的高级功能——信号。
Django的“信号分发器”允许解耦的应用在框架的其它地方发生操作时会被通知到。 简单来说，信号允许特定的sender通知一组receiver某些操作已经发生。 这在多处代码和同一事件有关联的情况下很有用。

信号的概念

Django2.1官文对signal的解释如下：

1
2
3
Django includes a "signal dispatcher" which helps allow decoupled applications get notified when actions occur elsewhere in the framework.
In a nutshell, signals allow certain senders to notify a set of receivers that some action has taken place. 
They are especially useful when many pieces of code may be interested in the same events.

翻译过来就是：Django框架内部包含了一个信号调度器，它的作用是可以将框架内部发生的任何操作都通知到功能独立的应用程序，当然，我们也可以缩小发送者和接收者的范围，即指定具体的发送者和接受者，假设我们的程序中有多个业务逻辑都在等待某一个事件发生之后再继续执行后面的代码，那么此时，信号是非常有用的。

Django内置的信号

Django内置的信号如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Model signals
    pre_init                    # django的model执行其构造方法前，自动触发
    post_init                   # django的model执行其构造方法后，自动触发
    pre_save                    # django的model对象保存前，自动触发
    post_save                   # django的model对象保存后，自动触发
    pre_delete                  # django的model对象删除前，自动触发
    post_delete                 # django的model对象删除后，自动触发
    m2m_changed                 # django的model中使用m2m字段操作第三张表（add,remove,clear）前后，自动触发
    class_prepared              # 程序启动时，检测已注册的app中modal类，对于每一个类，自动触发
Management signals
    pre_migrate                 # 执行migrate命令前，自动触发
    post_migrate                # 执行migrate命令后，自动触发
Request/response signals
    request_started             # 请求到来前，自动触发
    request_finished            # 请求结束后，自动触发
    got_request_exception       # 请求异常后，自动触发
Test signals
    setting_changed             # 使用test测试修改配置文件时，自动触发
    template_rendered           # 使用test测试渲染模板时，自动触发
Database Wrappers
    connection_created          # 创建数据库连接时，自动触发

Django内置信号的使用

注册内置信号

对于Django内置的信号，仅需注册指定信号，当程序执行相应操作时，自动触发注册函数。注册信号，写入与project同名的文件夹下的init.py文件中，也是换数据库引擎的地方。
2223
如上图，项目名为signalTest，我们在与项目同名的包的init.py文件中注册Django内置的信号，然后使用就可以了。

监听信号的2种方式

直接监听
1
2
3
4
5
6
7
def my_callback(sender, **kwargs):
    print("Request finished!")


from django.core.signals import request_finished

request_finished.connect(my_callback)
使用装饰器监听
1
2
3
4
5
6
7
8
def my_callback(sender, **kwargs):
    print("Request finished!")
from django.core.signals import request_finished
from django.dispatch import receiver

@receiver(request_finished)
def my_callback(sender, **kwargs):
    print("Request finished!")

注册时指定发送者

1
2
3
4
5
6
7
8
from django.db.models.signals import pre_save
from django.dispatch import receiver
from myapp.models import MyModel

# 在MyModel对应的数据保存前执行my_handler函数
@receiver(pre_save, sender=MyModel)
def my_handler(sender, **kwargs):
    xxx

注册完内置信号后，只要满足触发条件，对应的函数会在相应的条件下去执行，不用人手动去调用。

内置信号详细介绍

更多内置信号的说明请参考这篇博客：https://www.cnblogs.com/liwenzhou/p/9745331.html

自定义信号的使用

首先要知道的是，我们用的信号都是django.dispatch.Signal这个类的实例。

首先定义信号

在任意的py文件中定义信号：

1
2
import django.dispatch
signal_done = django.dispatch.Signal(providing_args=["height", "width"])

然后在与项目同名的包的__init__文件中注册信号

1
2
3
4
5
def callback(sender, **kwargs):
    print("callback")
    print(sender,kwargs)
 
signal_done.connect(callback)

最后在需要触发信号的地方使用自定义信号

1
2
3
from 路径 import signal_done
 
signal_done.send(sender='Naruto',height=123, width=456)

最后需要注意：由于内置信号的触发者已经集成到Django中，所以其会自动调用；而对于自定义信号则需要开发者在对应位置指定触发。

在路由分发前注册信号的方法

上面介绍的一种方式是在项目同名的包的__init__.py文件中去注册信号。
我们也可以利用Django在路由分发之前做一下信号的注册操作。
这里用到了Django启动的机制：django.dispatch.Signal在django.setup()的过程中，它会遍历settings.INSTALLED_APPS列表中的每一项，并调用该AppConfig的ready方法，因此，将recevier订阅signal的过程放置于ready方法中就能保证该代码的执行。
我们来拿一个具体的项目为例。

项目的目录结构如下

22331
（1）把所有的信号都写在了signals包中，并且signals包中的__init__.py文件中实例化Signal类的对象（注意Python在import一个包的时候会执行里面的__init__文件），执行的操作我写在了handlers.py文件中；
（2）然后，利用Django的启动的原理，我把信号的注册写在了apps.py的SignalappConfig类的ready方法中，保证在路由分发之前就注册自定义的信号。

注册信号的具体写法

signals/__init__.py
1
2
3
4
# -*- coding:utf-8 -*-
from django.dispatch import Signal

my_signal = Signal(providing_args=[])
signals/handlers.py：
1
2
3
# -*- coding:utf-8 -*-
def my_callback(sender,**kwargs):
    print('my_callback...')
signalapp/apps.py
1
2
3
4
5
6
7
8
9
10
11
12
from django.apps import AppConfig

# 从外部导入自定义信号及处理的函数
from signals import my_signal
from signals.handlers import my_callback

class SignalappConfig(AppConfig):
    name = 'signalapp'

    def ready(self):
        # 注册信号
        my_signal.connect(my_callback)

使用自定义的信号

做一个简单的路由与视图测试一下这个自定义的信号是否成功：

signalTest/urls.py
1
2
3
4
5
6
7
8
9
10
from django.contrib import admin
from django.urls import path

from signalapp import views


urlpatterns = [
    path('admin/', admin.site.urls),
    path('index/',views.index,name='index'),
]
sjgnalapp/views.py
1
2
3
4
5
6
7
8
from django.shortcuts import render,HttpResponse
# 导入自定义信号的处理函数
from signals.handlers import my_callback

def index(request):
    # 使用自定义信号
    my_callback(sender='index')
    return HttpResponse('OK')

启动Django程序后我们在浏览器中输入127.0.0.1:8000/index，可以看到在后台打印出了自定义信号处理函数中所打印的数据： 

1
my_callback...

定制信号的发送者

默认情况下，某些信号会被多次发送，但是，通常，我们只希望接收某个或者某些特定的发送者发出的信号，比如说django.db.models.signals.pre_saves，该信号，它在每个model的save()方法被执行的时候被发送，不过，很多情况下，我们只想记录某个特定的model的save()方法被执行时的日志。
在上述情况下，我们可以指定只接受我们指定的信号发送者发出的信号。
还是用django.db.models.signals.pre_saves举例，下面我们来演示如何指定发送者

1
2
3
4
5
6
7
8
from django.db.models.signals import pre_save

from django.dispatch import receiver
from myapp.models import MyModel

@receiver(pre_save, sender=MyModel)
def my_handler(sender, **kwargs):
    xxx

断开信号

如果不希望再接收某个信号，我们可以调用Signal.disconnect()方法。

更多内容详见官网文档

Django2.1信号signal文档

]]> <p>在真实的企业生产环境中，我们会遇到各种各样的需求，比如在全局对客户端请求进行过滤，将不满足某些条件的客户端请求过滤掉，这时我们可以利用Django的中间件来实现该需求；或者，我们希望每次model的save()方法被调用后，都要写一条日志到日志文件中，而此时我们可以通过Django提供的内置信号post_save来实现，本文介绍一下Django的高级功能——信号。<br>Django的“信号分发器”允许解耦的应用在框架的其它地方发生操作时会被通知到。 简单来说，信号允许特定的sender通知一组receiver某些操作已经发生。 这在多处代码和同一事件有关联的情况下很有用。 Pycharm与Python3中的TypeHint http://yoursite.com/2019/08/30/Pycharm与Python3中的TypeHint/ 2019-08-30T14:23:34.000Z 2019-09-21T04:28:21.223Z 也许有很多同学跟我一样一直使用Pycharm这个IDE作为主要的开发工具。但是在大型项目中Python这门动态语言本身并没有像C++/Java那样的类型声明的限制，这会导致我们在review代码或者接手别人的代码时产生很多困难。
还好自python3.5开始，PEP484为python引入了类型提示(TypeHint)。
类型提示是一种可以将你的函数变量声明为一种特定类型的声明。当然，类型提示并不是绑定，它仅仅是暗示，所以这种机制并不能阻止工程师传入他们不应该传入的参数。但是个人认为TypeHint是Python非常贴心的一个改进，因为添加了类型提示后，我们仅仅通过观察函数的定义就可以知道变量应该是什么类型。
另外需要注意Pycharm一定要用2017或更高的版本，否则你可能看不到Pycharm关于“类型错误”的提示。

类型提示的使用

不管是函数中传入的参数还是其返回值，基本上都会包括以下4类：

  • 基本内置类型，如 str，int，list
  • 基本类型组合产生的复杂类型，如 list[int], dict[str, int]
  • 用户自定的class作为类型提示
  • 函数参数，即 callable，比如回调参数：(value: str, index: int) -> str

    基本内置类型

    基本内置类型的提示很简单，只需要在函数定义阶段规定参数的类型及返回值类型即可
    1
    2
    3
    4
    5
    6
    def int_hint(a:int,b:int)->int:
        return a + b

    print(int_hint(11,22))
    # 程序本身不会报错，但是Pycharm会有提示
    print(int_hint('aa','bb'))

我们来看一下实际中Pycharm的提示：
tishi1

基本类型组合产生的复杂类型

这里我们需要使用Python的typing模块:

1
2
3
4
5
6
7
8
9
10
11
12
import typing

def my_hint(x:typing.List[str],y:typing.List[str])->typing.Dict[str,typing.List[str]]:
    return {
        'x':x,
        'y':y
    }

a = ['a1']
b = ['b1']

print(my_hint(a,b))

由上面的代码可知：my_hint函数接收2个参数，分别是列表里面嵌套一个字符串，它的返回值是一个字典，并且这个字典的key是str类型，value是列表嵌套字符串类型的值。
上面代码的结果为：

1
{'x': ['a1'], 'y': ['b1']}

用户自定的class作为类型提示

我们来看一下这个面向对象的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class People(object):
    def __init__(self,name):
        self.name = name

    def __str__(self):
        return self.name

class Dog(object):
    def __init__(self,name):
        self.name = name

    def __str__(self):
        return self.name

def sing(name:People)->None:
    print('{} is singing...'.format(name))

def bark(name:Dog)->None:
    print('{} is barking...'.format(name))

Tom = People('Tom')
Jerry = Dog('Jerry')

sing(Tom)
# Pycharm也会有提示
sing(Jerry)
bark(Jerry)

sing函数需要传入一个People对象，但是实际中传入的是一个Dog类实例化的对象，Pycharm也会提示：
xsa

函数参数 callable

这种情况是将一个函数作为参数实现参数的回调：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import typing

def create_dic(name:str,age:int)->dict:
    return {
        'name':name,
        'age':age   
    }

def my_callable(name:str,age:int,callback:typing.Callable[[str,int],dict]):
    ret = callback(name,age)
    return ret

# 将create_dict函数传进去，注意是在my_callable函数中执行
print(my_callable('wanghw',18,create_dic))

执行结果为：

1
{'name': 'wanghw', 'age': 18}

当然，这种方式在实际中使用的并不多，但是遇到的话我们也应该能够读懂代码。

参考文章

https://juejin.im/post/5a8ed8f9f265da4e6e2bd920
https://www.cnblogs.com/sddai/p/11458757.html
https://www.cnblogs.com/zhbzz2007/p/6200515.html

]]> <p>也许有很多同学跟我一样一直使用Pycharm这个IDE作为主要的开发工具。但是在大型项目中Python这门动态语言本身并没有像C++/Java那样的类型声明的限制，这会导致我们在review代码或者接手别人的代码时产生很多困难。<br>还好自python3.5开始，PEP484为python引入了类型提示(TypeHint)。<br>类型提示是一种可以将你的函数变量声明为一种特定类型的声明。当然，类型提示并不是绑定，它仅仅是暗示，所以这种机制并不能阻止工程师传入他们不应该传入的参数。但是个人认为TypeHint是Python非常贴心的一个改进，因为添加了类型提示后，我们仅仅通过观察函数的定义就可以知道变量应该是什么类型。<br>另外需要注意Pycharm一定要用2017或更高的版本，否则你可能看不到Pycharm关于“类型错误”的提示。 Python异常处理 http://yoursite.com/2019/08/17/Python异常处理/ 2019-08-17T13:34:01.000Z 2020-01-06T14:54:40.441Z 本文将详细介绍Python中常见的错误与异常以及处理异常的具体方法。

Python异常的分类

Python中的错误主要分为2种：一种是语法错误，另外一种是逻辑错误。
语法错误在Python解释器进行语法检测的时候就会被“捕获”到，也就是说，如果代码中存在语法错误，那这段代码所在的整个程序都不会执行！
常见的语法错误示范如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 函数后没加引号
def test()
    pass

# 只有一个关键字
for

# 调用方法没写完整
def test():
    pass
test(
    
# and so on
...

第二种逻辑错误是在我们执行Python代码期间产生的异常，它虽然可以通过Python的“语法检测”，但是因为逻辑问题会抛出异常：

1
2
3
4
5
6
7
8
9
# int强转一个非数字的字符串
s = "wanghw"
d = int(s)

# 分母为0
a = 1/0

# and so on
...

代码中捕获的异常

在Python的IDE下捕获的异常一般是这样的：
123

常见的异常

Python中常见的异常如下：

1
2
3
4
5
6
7
8
9
10
11
12
"AttributeError" 试图访问一个对象没有的属性，比如foo.x，但是foo没有属性x
"IOError" 输入/输出异常；基本上是无法打开文件
"ImportError" 无法引入模块或包；基本上是路径问题或名称错误
"IndentationError" 语法错误（的子类） ；代码没有正确对齐
"IndexError" 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]
"KeyError" 试图访问字典里不存在的键
"KeyboardInterrupt" Ctrl+C被按下
"NameError" 使用一个还未被赋予对象的变量
"SyntaxError" Python代码非法，代码不能编译(个人认为这是语法错误，写错了）
"TypeError" 传入对象类型与要求的不符合
"UnboundLocalError" 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，导致你以为正在访问它
"ValueError" 传入一个调用者不期望的值，即使值的类型是正确的

其他的异常信息如下：

其他更多异常
ArithmeticErrorAssertionErrorAttributeErrorBaseExceptionBufferErrorBytesWarningDeprecationWarningEnvironmentErrorEOFErrorExceptionFloatingPointErrorFutureWarningGeneratorExitImportErrorImportWarningIndentationErrorIndexErrorIOErrorKeyboardInterruptKeyErrorLookupErrorMemoryErrorNameErrorNotImplementedErrorOSErrorOverflowErrorPendingDeprecationWarningReferenceErrorRuntimeErrorRuntimeWarningStandardErrorStopIterationSyntaxErrorSyntaxWarningSystemErrorSystemExitTabErrorTypeErrorUnboundLocalErrorUnicodeDecodeErrorUnicodeEncodeErrorUnicodeErrorUnicodeTranslateErrorUnicodeWarningUserWarningValueErrorWarningZeroDivisionError

异常处理

上面介绍了什么是异常，接下来详细说明一下Python中如何进行异常处理。

异常处理的概念

python解释器检测到错误，触发异常（也允许程序员自己触发异常）。
程序员编写特定的代码，专门用来捕捉这个异常（这段代码与程序逻辑无关，与异常处理有关）。
如果捕捉成功则进入另外一个处理分支，执行你为其定制的逻辑，使程序不会崩溃，这就是异常处理。

为什么要进行异常处理

python解析器去执行程序，检测到了一个错误时，触发异常，异常触发后且没被处理的情况下，程序就在当前异常处终止，后面的代码不会运行，谁会去用一个运行着突然就崩溃的软件。
所以你必须提供一种异常处理机制来增强你程序的健壮性与容错性。

如何进行异常处理

首先须知，异常是由程序的错误引起的，语法上的错误跟异常处理无关，必须在程序运行前就修正！

Python中的异常处理

Python中使用try...except代码块来处理异常。
基本语法如下：

1
2
3
4
try:
     被检测的代码块
except 异常类型：
     try中一旦检测到异常，就执行这个位置的逻辑

如果在执行 try 块里的业务逻辑代码时出现异常，系统自动生成一个异常对象，该异常对象被提交给 Python 解释器，这个过程被称为引发异常。
当 Python 解释器收到异常对象时，会寻找能处理该异常对象的 except 块，如果找到合适的 except 块，则把该异常对象交给该 except 块处理，这个过程被称为捕获异常。如果 Python 解释器找不到捕获异常的 except 块，则运行时环境终止，Python 解释器也将退出。
不管程序代码块是否处于 try 块中，甚至包括 except 块中的代码，只要执行该代码块时出现了异常，系统总会自动生成一个 Error 对象。如果程序没有为这段代码定义任何的 except 块，则 Python 解释器无法找到处理该异常的 except 块，程序就在此退出。
拿一个具体的实例来说：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
try:
    f = open('a.txt')
    g = (line.strip() for line in f)
    print(next(g))
    print(next(g))
    print(next(g))
    print(next(g))
    print(next(g))
except StopIteration:
    f.close()
'''
next(g)会触发迭代f，依次next(g)就可以读取文件的一行行内容，无论文件a.txt有多大，同一时刻内存中只有一行内容。
提示：g是基于文件句柄f而存在的，因而只能在next(g)抛出异常StopIteration后才可以执行f.close()
'''
单个except块只能处理指定的异常

异常类只能用来处理指定的异常情况，如果非指定异常则无法处理

1
2
3
4
5
6
# 未捕获到异常，程序直接报错
s1 = 'hello'
try:
    int(s1)
except IndexError as e:
    print e
多分支捕获多种异常
1
2
3
4
5
6
7
8
9
s1 = 'hello'
try:
    int(s1)
except IndexError as e:
    print(e)
except KeyError as e:
    print(e)
except ValueError as e:
    print(e)
万能异常

使用万能异常Exception可以捕获所有的异常：

1
2
3
4
5
s1 = 'hello'
try:
    int(s1)
except Exception as e:
    print(e)
多分支 VS 万能异常

1、如果你想要的效果是，无论出现什么异常，我们统一丢弃，或者使用同一段代码逻辑去处理他们，那么骚年，大胆的去做吧，只有一个Exception就足够了。 

1
2
3
4
5
6
7
8
s1 = 'hello'
try:
    int(s1)
except Exception,e:
    '丢弃或者执行其他逻辑'
    print(e)

#如果你统一用Exception，没错，是可以捕捉所有异常，但意味着你在处理所有异常时都使用同一个逻辑去处理（这里说的逻辑即当前expect下面跟的代码块）

2、如果你想要的效果是，对于不同的异常我们需要定制不同的处理逻辑，那就需要用到多分支了。

1
2
3
4
5
6
7
8
9
s1 = 'hello'
try:
    int(s1)
except IndexError as e:
    print(e)
except KeyError as e:
    print(e)
except ValueError as e:
    print(e)
1
2
3
4
5
6
7
8
9
10
11
s1 = 'hello'
try:
    int(s1)
except IndexError as e:
    print(e)
except KeyError as e:
    print(e)
except ValueError as e:
    print(e)
except Exception as e:
    print(e)
主动触发异常
1
2
3
4
try:
    raise TypeError('类型错误')
except Exception as e:
    print(e)
自定义异常
1
2
3
4
5
6
7
8
9
10
11
12
# 自定义异常
class HuoException(Exception):
    def __init__(self,msg):
        self.msg = msg

    def __str__(self):
        return self.msg

try:
raise HuoException("huoyingwhw aaa")
except HuoException as e:
print(e)
Python异常类的继承顺序

12322
从上图 中可以看出，Python 的所有异常类的基类是 BaseException，但如果用户要实现自定义异常，则不应该继承这个基类，而是应该继承 Exception 类。
BaseException 的主要子类就是 Exception，不管是系统的异常类，还是用户自定义的异常类，都应该从 Exception 派生。

异常的继承关系
BaseException +-- SystemExit +-- KeyboardInterrupt +-- GeneratorExit +-- Exception      +-- StopIteration      +-- StandardError      |    +-- BufferError      |    +-- ArithmeticError      |    |    +-- FloatingPointError      |    |    +-- OverflowError      |    |    +-- ZeroDivisionError      |    +-- AssertionError      |    +-- AttributeError      |    +-- EnvironmentError      |    |    +-- IOError      |    |    +-- OSError      |    |         +-- WindowsError (Windows)      |    |         +-- VMSError (VMS)      |    +-- EOFError      |    +-- ImportError      |    +-- LookupError      |    |    +-- IndexError      |    |    +-- KeyError      |    +-- MemoryError      |    +-- NameError      |    |    +-- UnboundLocalError      |    +-- ReferenceError      |    +-- RuntimeError      |    |    +-- NotImplementedError      |    +-- SyntaxError      |    |    +-- IndentationError      |    |         +-- TabError      |    +-- SystemError      |    +-- TypeError      |    +-- ValueError      |         +-- UnicodeError      |              +-- UnicodeDecodeError      |              +-- UnicodeEncodeError      |              +-- UnicodeTranslateError      +-- Warning           +-- DeprecationWarning           +-- PendingDeprecationWarning           +-- RuntimeWarning           +-- SyntaxWarning           +-- UserWarning           +-- FutureWarning       +-- ImportWarning       +-- UnicodeWarning       +-- BytesWarning

Python异常处理的else块

在 Python 的异常处理流程中还可添加一个 else 块，当 try 块没有出现异常时，程序会执行 else 块。例如如下程序： 

1
2
3
4
5
6
7
8
9
10
s = input('请输入除数:')
try:
    result = 20 / int(s)
    print('20除以%s的结果是: %g' % (s , result))
except ValueError:
    print('值错误，您必须输入数值')
except ArithmeticError:
    print('算术错误，您不能输入0')
else:
    print('没有出现异常')

上面程序为异常处理流程添加了 else 块，当程序中的 try 块没有出现异常时，程序就会执行 else 块。运行上面程序，如果用户输入导致程序中的 try 块出现了异常，则运行结果如下： 

1
2
请输入除数：a
值错误，您必须输入数值

如果用户输入让程序中的 try 块顺利完成，则运行结果如下： 

1
2
3
请输入除数：3
20 除以3 的结果是：6.66667
没有出现异常

看到这里，可能有读者觉得奇怪：既然只有当 try 块没有异常时才会执行 else 块，那么直接把 else 块的代码放在 try 块的代码的后面不就行了？
实际上大部分语言的异常处理都没有 else 块，它们确实是将 else 块的代码直接放在 try 块的代码的后面的，因为对于大部分场景而言，直接将 else 块的代码放在 try 块的代码的后面即可。
但 Python 的异常处理使用 else 块绝不是多余的语法，当 try 块没有异常，而 else 块有异常时，就能体现出 else 块的作用了。例如如下程序： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def else_test():
    s = input('请输入除数:')
    result = 20 / int(s)
    print('20除以%s的结果是: %g' % (s , result))
def right_main():
    try:
        print('try块的代码，没有异常')
    except:
        print('程序出现异常')
    else:
        # 将else_test放在else块中
        else_test()
def wrong_main():
    try:
        print('try块的代码，没有异常')
        # 将else_test放在try块代码的后面
        else_test()
    except:
        print('程序出现异常')
wrong_main()
right_main()

上面程序中定义了一个 else_test() 函数，该函数在运行时需要接收用户输入的参数，随着用户输入数据的不同可能导致异常。接下来程序定义了 right_main() 和 wrong_main() 两个函数，其中 right_main() 将 else_test() 函数放在 else 块内；而 wrong_main() 将 else_test() 函数放在 try 块的代码的后面。
正如上面所介绍的，当 try 块和 else 块都没有异常时，将 else_test() 函数放在 try 块的代码的后面和放在 else 块中没有任何区别。例如，如果用户输入的数据没有导致程序出现异常，则将看到程序产生如下输出结果： 

1
2
3
4
5
6
try块的代码，没有异常
请输入除数:4
20除以4的结果是: 5
try块的代码，没有异常
请输入除数:4
20除以4的结果是: 5

但如果用户输入的数据让 else_test() 函数出现异常（try 块依然没有任何异常），此时程序就会产生如下输出结果： 

1
2
3
4
5
6
7
8
9
10
11
12
13
try块的代码，没有异常
请输入除数:0
程序出现异常
try块的代码，没有异常
请输入除数:0
Traceback (most recent call last):
  File "C:\Users\mengma\Desktop\1.py", line 21, in <module>
    right_main()
  File "C:\Users\mengma\Desktop\1.py", line 12, in right_main
    else_test()
  File "C:\Users\mengma\Desktop\1.py", line 3, in else_test
    result = 20 / int(s)
ZeroDivisionError: division by zero

对比上面两个输出结果，用户输入的都是 0，这样都会导致 else_test() 函数出现异常。如果将 else_test() 函数放在 try 块的代码的后面，此时 else_test() 函数运行产生的异常将会被 try 块对应的 except 捕获，这正是 Python 异常处理机制的执行流程：但如果将 else_test() 函数放在 else 块中，当 else_test() 函数出现异常时，程序没有 except 块来处理该异常，该异常将会传播给 Python 解释器，导致程序中止。
对比上面两个输出结果，不难发现，放在 else 块中的代码所引发的异常不会被 except 块捕获。
所以，如果希望某段代码的异常能被后面的 except 块捕获，那么就应该将这段代码放在 try 块的代码之后；如果希望某段代码的异常能向外传播（不被 except 块捕获），那么就应该将这段代码放在 else 块中。

Python异常处理的finally块

finally块中的代码无论是否发生了异常都会执行，通常进行操作系统资源的清理工作。

1
2
3
4
5
6
7
8
9
# finally块
try:
    f = open("lru1.py")
    contents = f.read()
    print(contents)
except Exception as e:
    print(e)
finally:
    f.close()

如何合理的使用异常处理

有的同学会这么想，学完了异常处理后，好强大，我要为我的每一段程序都加上try…except，干毛线去思考它会不会有逻辑错误啊，这样就很好啊，多省脑细胞 - -!
try…except应该尽量少用，因为它本身就是你附加给你的程序的一种异常处理的逻辑，与你的主要的工作是没有关系的
这种东西加的多了，会导致你的代码可读性变差，只有在有些异常无法预知的情况下，才应该加上try…except，其他的逻辑错误应该尽量修正

参考文章

http://c.biancheng.net/view/2315.html
https://www.cnblogs.com/Eva-J/articles/7281240.html

]]> <p>本文将详细介绍Python中常见的错误与异常以及处理异常的具体方法。 Flask的版本与返回字典数据的问题 http://yoursite.com/2019/08/10/Flask的版本与返回字典数据的问题/ 2019-08-10T01:33:59.000Z 2019-09-21T04:28:21.222Z 以往我们用flask返回一个字典的时候都会先用jsonify方法把这个字典序列化一下再返回：

1
2
3
4
5
6
7
8
from flask import Flask,jsonify

app = Flask(__name__)

@app.route("/")
def home():
dic = {"name":"whw","age":18}
return jsonify(dic)
如果直接返回字典的话会报一个`TypeError`的错误！

123
如果访问index的话会报错：

1
TypeError:'dict' object is not callable

1.1.1版本的flask可以直接返回字典

但是，最近发现了一个十分奇妙的问题：1.11版本的flask是可以直接返回字典的：
222
可以访问index看一下结果，字典被成功返回了！
333
很神奇，看来flask改版以后优化了返回的数据的结构！

]]> <p>以往我们用flask返回一个字典的时候都会先用<code>jsonify</code>方法把这个字典序列化一下再返回：</p> <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">from</span> flask <span class="keyword">import</span> Flask,jsonify</span><br><span class="line"></span><br><span class="line">app = Flask(__name__)</span><br><span class="line"></span><br><span class="line"><span class="meta">@app.route("/")</span></span><br><span class="line"><span class="function"><span class="keyword">def</span> <span class="title">home</span><span class="params">()</span>:</span></span><br><span class="line"> dic = &#123;<span class="string">"name"</span>:<span class="string">"whw"</span>,<span class="string">"age"</span>:<span class="number">18</span>&#125;</span><br><span class="line"> <span class="keyword">return</span> jsonify(dic)</span><br></pre></td></tr></table></figure> 浅谈Python中字典的打散传参 http://yoursite.com/2019/08/09/浅谈Python中字典的打散传参/ 2019-08-09T08:56:59.000Z 2019-09-21T04:28:21.225Z 实际开发中我们常会遇到将用户提交的数据经过校验后存入数据库的操作。
假设用户使用form表单以post方式往Customer表中提交数据，后台接收到数据后往往会这样进行处理：

1
2
3
4
# 将csrf校验的键值对去除
request.POST.pop("csrfmiddlewaretoken")
# 以打散的方式将数据传入数据库的表中
Customer.objects.update_or_create(**request.POST)

我们知道，request.POST是一个QueryDict对象，实际上它是一个自定义的字典，除了修改的时候需要注意其不可变特性以外，在进行传参的时候我们可以把它当作一个字典。
而且需要注意的是，这种“打散”的方式传参要求这个字典中的所有的key必须跟数据库的表中的字段的名字一致！否则传参的时候会发生错误！

一个小demo解释字典打散传参的机理

那么问题来了：这种打散的方式的机制是什么呢？
来看下面的例子：

1
2
3
4
5
6
7
8
9
10
11
def func(username,password):
global count
print(count,username,password)
count += 1

if __name__ == '__main__':
count = 1
dic = {"username":'whw','password':123}
# 打散传参与位置参数传参
func(**dic)
func(username='whw',password=123)

执行的结果如下：

1
2
1 whw 123
2 whw 123

首先，我们先定义了一个函数func，里面有两个位置参数username与password，然后又定义了一个字典dic={"username":"whw","password":123}，count变量作为一个计数器使用。
然后，执行func函数的时候我们采用了两种方式去传参：一种只**dic方式，也就是将dic打散；另外一种是常规的传参方式。
两种方式都正常执行，说明上述两种传参方式是等价的！
也就是说：**dic将字典打散成了一个个的key=value的形式！
另外，还需要特别注意的一点是：这种传参的方式对字典的key是有要求的，被打散的字典的key值必须与函数的位置参数的值一致，否则程序会报错！

]]> <p>实际开发中我们常会遇到将用户提交的数据经过校验后存入数据库的操作。<br>假设用户使用form表单以post方式往Customer表中提交数据，后台接收到数据后往往会这样进行处理：</p> <figure class="highlight python"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment"># 将csrf校验的键值对去除</span></span><br><span class="line">request.POST.pop(<span class="string">"csrfmiddlewaretoken"</span>)</span><br><span class="line"><span class="comment"># 以打散的方式将数据传入数据库的表中</span></span><br><span class="line">Customer.objects.update_or_create(**request.POST)</span><br></pre></td></tr></table></figure> <p>我们知道，request.POST是一个<code>QueryDict</code>对象，实际上它是一个自定义的<code>字典</code>，除了修改的时候需要注意其<code>不可变特性</code>以外，在进行传参的时候我们可以把它当作一个字典。<br>而且需要注意的是，这种“打散”的方式传参要求这个<code>字典</code>中的所有的<code>key</code>必须跟数据库的表中的字段的名字一致！否则传参的时候会发生错误！