2019-05-04 15:53:22 +08:00
## RESTful架构和DRF入门
2019-02-13 07:38:52 +08:00
2020-07-15 12:12:49 +08:00
把软件（ ） （ ） （ ） （ ） ， （ ） （ ） （ ） （ ） ， （ ） ， ， ； ， ， ， ， ，
2019-02-13 07:38:52 +08:00
2020-07-15 12:12:49 +08:00
### REST概述
REST这个词， ， （ ） ， ， **S**tate **T**ransfer的缩写， 表现层状态转移**”或“**表述状态转移**”。
这里的“表现层”其实指的是“资源”的“表现层”。所谓资源， ， （ ） ， ， ， ， ， ， ， ， ， ， ， ，
访问一个网站， ， ， ， ， ， ， （ ） ， ， ， （ ） ， （ ） ，
简单的说RESTful架构就是： ， ， ，
我们在设计Web应用时， ， ， ， ， ， ，
| 请求方法（ ）
| -------------------- | -------------------------- | -------------------------------------------- |
| **GET** | `/students/` | 获取所有学生 |
| **POST** | `/students/` | 新建一个学生 |
| **GET** | `/students/ID/` | 获取指定ID的学生信息 |
| **PUT** | `/students/ID/` | 更新指定ID的学生信息（ ）
| **PATCH** | `/students/ID/` | 更新指定ID的学生信息（ ）
| **DELETE** | `/students/ID/` | 删除指定ID的学生信息 |
| **GET** | `/students/ID/friends/` | 列出指定ID的学生的所有朋友 |
| **DELETE** | `/students/ID/friends/ID/` | 删除指定ID的学生的指定ID的朋友 |
### DRF使用入门
在Django项目中， ， ， ，
#### 安装和配置DRF
安装DRF。
```Shell
pip install djangorestframework
```
配置DRF。
```Python
INSTALLED_APPS = [
'rest_framework',
]
# 下面的配置根据项目需要进行设置
REST_FRAMEWORK = {
# 配置默认页面大小
# 'PAGE_SIZE': 10,
# 配置默认的分页类
2020-10-12 07:41:09 +08:00
# 'DEFAULT_PAGINATION_CLASS': '...',
2020-07-15 12:12:49 +08:00
# 配置异常处理器
# 'EXCEPTION_HANDLER': '...',
# 配置默认解析器
# 'DEFAULT_PARSER_CLASSES': (
# 'rest_framework.parsers.JSONParser',
# 'rest_framework.parsers.FormParser',
# 'rest_framework.parsers.MultiPartParser',
# ),
# 配置默认限流类
# 'DEFAULT_THROTTLE_CLASSES': (
# '...'
# ),
# 配置默认授权类
# 'DEFAULT_PERMISSION_CLASSES': (
# '...',
# ),
# 配置默认认证类
# 'DEFAULT_AUTHENTICATION_CLASSES': (
# '...',
# ),
}
```
#### 编写序列化器
前后端分离的开发需要后端为前端、移动端提供API数据接口， ，
```Python
2020-10-19 18:05:56 +08:00
from rest_framework import serializers
2020-07-15 12:12:49 +08:00
class SubjectSerializer(serializers.ModelSerializer):
class Meta:
model = Subject
fields = '__all__'
```
上面的代码直接继承了`ModelSerializer`，通过`Meta`类的`model`属性指定要序列化的模型以及`fields`属性指定需要序列化的模型字段，稍后我们就可以在视图函数中使用该类来实现对`Subject`模型的序列化。
#### 编写视图函数
DRF框架支持两种实现数据接口的方式， （ ） ， （ ） ，
```Python
2020-10-19 18:05:56 +08:00
from rest_framework.decorators import api_view
from rest_framework.response import Response
2020-07-15 12:12:49 +08:00
@api_view (('GET', ))
def show_subjects(request: HttpRequest) -> HttpResponse:
subjects = Subject.objects.all().order_by('no')
# 创建序列化器对象并指定要序列化的模型
serializer = SubjectSerializer(subjects, many=True)
# 通过序列化器的data属性获得模型对应的字典并通过创建Response对象返回JSON格式的数据
return Response(serializer.data)
```
对比上一个章节的使用`bpmapper`实现模型序列化的代码， ， ， ，
直接使用上一节写好的页面， ，
#### 实现老师信息数据接口
编写序列化器。
```Python
class SubjectSimpleSerializer(serializers.ModelSerializer):
class Meta:
model = Subject
fields = ('no', 'name')
class TeacherSerializer(serializers.ModelSerializer):
class Meta:
model = Teacher
exclude = ('subject', )
```
编写视图函数。
```Python
@api_view (('GET', ))
def show_teachers(request: HttpRequest) -> HttpResponse:
try:
sno = int(request.GET.get('sno'))
subject = Subject.objects.only('name').get(no=sno)
teachers = Teacher.objects.filter(subject=subject).defer('subject').order_by('no')
subject_seri = SubjectSimpleSerializer(subject)
teacher_seri = TeacherSerializer(teachers, many=True)
return Response({'subject': subject_seri.data, 'teachers': teacher_seri.data})
except (TypeError, ValueError, Subject.DoesNotExist):
return Response(status=404)
```
配置URL映射。
```Python
urlpatterns = [
path('api/teachers/', show_teachers),
]
```
通过Vue.js渲染页面。
2020-07-21 07:50:07 +08:00
```HTML
2020-07-15 12:12:49 +08:00
<!DOCTYPE html>
< html lang = "en" >
< head >
< meta charset = "UTF-8" >
< title > 老师信息< / title >
< style >
2020-07-21 07:50:07 +08:00
/* 此处省略掉层叠样式表 */
2020-07-15 12:12:49 +08:00
< / style >
< / head >
< body >
< div id = "container" >
< h1 > {{ subject.name }}学科的老师信息< / h1 >
< hr >
2020-09-24 07:36:20 +08:00
< h2 v-if = "loaded && teachers.length == 0" > 暂无该学科老师信息< / h2 >
2020-07-15 12:12:49 +08:00
< div class = "teacher" v-for = "teacher in teachers" >
< div class = "photo" >
< img :src = "'/static/images/' + teacher.photo" height = "140" alt = "" >
< / div >
< div class = "info" >
< div >
< span > < strong > 姓名：{{ teacher.name }}< / strong > < / span >
< span > 性别：{{ teacher.sex | maleOrFemale }}< / span >
< span > 出生日期：{{ teacher.birth }}< / span >
< / div >
< div class = "intro" > {{ teacher.intro }}< / div >
< div class = "comment" >
2020-09-24 07:36:20 +08:00
< a href = "" @click . prevent = "vote(teacher, true)" > 好评</ a >
2020-07-21 07:50:07 +08:00
(< strong > {{ teacher.good_count }}< / strong > )
2020-07-15 12:12:49 +08:00
2020-09-24 07:36:20 +08:00
< a href = "" @click . prevent = "vote(teacher, false)" > 差评</ a >
2020-07-21 07:50:07 +08:00
(< strong > {{ teacher.bad_count }}< / strong > )
2020-07-15 12:12:49 +08:00
< / div >
< / div >
< / div >
2020-09-24 07:36:20 +08:00
< a href = "/static/html/subjects.html" > 返回首页< / a >
2020-07-15 12:12:49 +08:00
< / div >
< script src = "https://cdn.bootcdn.net/ajax/libs/vue/2.6.11/vue.min.js" > < / script >
< script >
let app = new Vue({
el: '#container',
data: {
2020-09-24 07:36:20 +08:00
subject: {},
teachers: [],
loaded: false
2020-07-15 12:12:49 +08:00
},
created() {
fetch('/api/teachers/' + location.search)
.then(resp => resp.json())
.then(json => {
this.subject = json.subject
this.teachers = json.teachers
})
},
filters: {
maleOrFemale(sex) {
return sex? '男': '女'
}
},
methods: {
2020-09-24 07:36:20 +08:00
vote(teacher, flag) {
let url = flag? '/praise/' : '/criticize/'
url += '?tno=' + teacher.no
fetch(url).then(resp => resp.json()).then(json => {
if (json.code === 10000) {
if (flag) {
2020-07-15 12:12:49 +08:00
teacher.good_count = json.count
} else {
teacher.bad_count = json.count
}
2020-09-24 07:36:20 +08:00
}
})
2020-07-15 12:12:49 +08:00
}
}
})
< / script >
< / body >
< / html >
```
### 前后端分离下的用户登录
之前我们提到过， HTTP是无状态的， ， ， ， ， ， ，
之前我们做会话管理（ ） ： ， ， ； ， ， ， ， ， ， ， （ ， ） ， ， ， ， ， （ ） ， ； ，
基于token的用户跟踪是在用户登录成功后， （ ） ， ， ：
1. 用户登录时， （ ） ， （ ） ， ；
2. 前端获取到服务器返回的token， （ ， ， ） ；
3. 对于使用了前端路由的项目来说，前端每次路由跳转，可以先判断`localStroage`中有无token， ；
4. 每次请求后端数据接口， ； ， ， ；
5. 如果前端收到HTTP响应状态码401，
通过上面的描述， ， ， ，
#### JWT概述
JSON Web Token通常简称为JWT， （ ） ， ， ， （ ） （ ） （ ） ，
1. 头部
```JSON
{
"alg": "HS256",
"typ": "JWT"
}
```
其中，`alg`属性表示签名的算法， （ ） ； ，
2. 载荷
载荷部分用来存放实际需要传递的数据。JWT官方文档中规定了7个可选的字段：
- iss ：签发人
- exp：
- sub：
- aud：
- nbf：
- iat：
- jti：
除了官方定义的字典，我们可以根据应用的需要添加自定义的字段，如下所示。
```JSON
{
"sub": "1234567890",
"nickname": "jackfrued",
"role": "admin"
}
```
3. 签名
签名部分是对前面两部分生成一个指纹，防止数据伪造和篡改。实现签名首先需要指定一个密钥。这个密钥只有服务器才知道，不能泄露给用户。然后，使用头部指定的签名算法（默认是`HS256`），按照下面的公式产生签名。
```Python
HS256(base64Encode(header) + '.' + base64Encode(payload), secret)
```
算出签名以后，把头部、载荷、签名三个部分拼接成一个字符串，每个部分用`.`进行分隔，
#### JWT的优缺点
使用JWT的优点非常明显， ：
1. 更容易实现水平扩展，因为令牌保存在浏览器中，服务器不需要做状态管理。
2. 更容易防范CSRF攻击， ，
3. 可以防伪造和篡改， ， ，
当然， ， ， ， ：
1. 可能会遭受到XSS攻击（ ） ，
2. 在令牌过期之前，无法作废已经颁发的令牌，要解决这个问题，还需要额外的中间层和代码来辅助。
3. JWT是用户的身份令牌， ， ， ， ，
2020-07-21 07:50:07 +08:00
#### 使用PyJWT
2020-07-15 12:12:49 +08:00
在Python代码中， ，
```Bash
pip install pyjwt
```
生成令牌。
```Python
payload = {
'exp': datetime.datetime.utcnow() + datetime.timedelta(days=1),
'userid': 10001
}
token = jwt.encode(payload, settings.SECRET_KEY).decode()
```
验证令牌。
```Python
try:
token = 'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE1OTQ4NzIzOTEsInVzZXJpZCI6MTAwMDF9.FM-bNxemWLqQQBIsRVvc4gq71y42I9m2zt5nlFxNHUo'
payload = jwt.decode(token, settings.SECRET_KEY)
except InvalidTokenError:
raise AuthenticationFailed('无效的令牌或令牌已经过期')
```
2020-10-19 18:05:56 +08:00
如果不清楚JWT具体的使用方式， ，
