###中间件
- 浏览器
- wsgi Web服务器网关接口 Web Server Gateway Interface
- middleware 中间件
- process_request(self, request)
- 参数
- request 请求对象
- 在路由和视图函数执行之前
- 中间件根据注册的先后，顺序执行
- 返回值为None 正常流程
- 返回HttpResponse，则不会继续走中间件后面的类，也不会走路由和视图函数，直接返回给浏览器
- process_response(self, request, response)
- 参数
- request 请求对象
- response 响应对象
- 在路由和视图函数执行之后
- 中间件根据注册的先后，倒序执行
- 返回值为None 会报错
- 直接返回response对象
- process_view(self, request, view_func, view_args, view_kwargs)
- 参数
- request 请求对象
- view_func 视图函数
- view_args 视图函数的位置参数
- view_kwargs 视图函数的关键字参数
- 在视图函数执行前，在路由执行后
- 中间件根据注册的先后，顺序执行
- 返回值为None 正常流程
- 返回HttpResponse,会从最后一个process_response开始执行，然后返回给浏览器
- process_exception(self, request, exception)
- 参数
- request 请求对象
- exception 异常对象
- 在视图函数出错时执行
- 中间件根据注册的先后，倒序执行
- 返回值为None 正常流程
- 返回HttpResponse, 不在继续执行后续的中间件中的process_exception方法
直接返回到最后一个process_response方法，然后返回给浏览器。
- process_template_response(self, request, response)
- 参数
- request 请求对象
- response 响应对象
- 在视图函数调用TemplateResponse时执行
- 中间件根据注册的先后，倒序执行
- 返回Response对象
- my_middlewares.py
```python
# -*- coding: utf-8 -*-
from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import HttpResponse
class MD1(MiddlewareMixin):
def process_request(self, request):
print("process_request MD1")
# return HttpResponse('md1')
def process_response(self, request, response):
print("process_response MD1")
return response
def process_view(self, request, view_func, view_args, view_kwargs):
print("process_view MD1")
# return HttpResponse("process_view MD1")
def process_exception(self, request, exception):
print("process_exception MD1")
print(exception, "MD1")
def process_template_response(self, request, response):
print("process_template_response MD1")
return response
class MD2(MiddlewareMixin):
def process_request(self, request):
print("process_request MD2")
def process_response(self, request, response):
print("process_response MD2")
return response
def process_view(self, request, view_func, view_args, view_kwargs):
print("process_view MD2")
# return HttpResponse("process_view MD2")
def process_exception(self, request, exception):
print("process exception MD2")
print(exception, "MD2")
def process_template_response(self, request, response):
print("process_template_response MD2")
return response
class MD3(MiddlewareMixin):
def process_request(self, request):
print("process_request MD3")
def process_response(self, request, response):
print("process_response MD3")
return response
def process_view(self, request, view_func, view_args, view_kwargs):
print("process_view MD3")
# return HttpResponse("process_view MD3")
def process_exception(self, request, exception):
print("process_exception MD3")
print(exception, "MD3")
# return HttpResponse(exception)
def process_template_response(self, request, response):
print("process_template_response MD3")
response.template_name = "index1.html"
response.context_data['name'] = 'lucy'
return response
```
- settings.py
```python
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
...
'app01.my_middlewares.MD1',
'app01.my_middlewares.MD2',
'app01.my_middlewares.MD3',
]
```
- url路由表
- views视图函数
- orm 数据库表（类）
- template 模板
###JSON是什么？
- JSON指的是JavaScript对象表示法(JavaScript Object Notation)
- JSON是轻量级的文本数据交换格式
- JSON独立于语言
- JSON具有自我描述性，更易理解
- 属性名必须使用双引号
- 不能使用十六进制作为属性值
- 不能使用undefined作为属性值
- 不能使用函数和日期对象作为属性值
###Javascript对象和JSON的转化
```javascript
test_obj = {'name':'lily'}
//Object { name: "lily" }
test_json = JSON.stringify(test_obj)
//"{"name":"lily"}"
test_obj = JSON.parse(test_json)
//Object { name: "lily" }
```
###AJAX 异步的Javascript和Xml (Asynchnorous Javascript And Xml)
###通过form表单提交实现算术运算
```html
<form action="" method="post">
<p>
{% csrf_token %}
<input type="text" name="num1" value="{{ num1 }}"> +
<input type="text" name="num2" value="{{ num2 }}"> =
<input type="text" name="num3" value="{{ num3 }}">
<button>计算</button>
</p>
<p>
<input type="text" name="num11" value="{{ num11 }}"> +
<input type="text" name="num22" value="{{ num22 }}"> =
<input type="text" name="num33" value="{{ num33 }}">
<input type="button" id="btn_id" value="计算">
</p>
<p>
<input type="button" id="btn1" value="Ajax测试">
</p>
</form>
```
```python
from django.shortcuts import render
def calc(request):
if request.method == 'POST':
num1 = request.POST.get('num1')
num2 = request.POST.get('num2')
num3 = int(num1) + int(num2)
return render(request, 'calc.html', {'num1': num1, 'num2': num2, 'num3': num3})
return render(request, 'calc.html')
```
###通过Ajax实现算术运算
```javascript
$("#btn_id").click(function () {
var num1 = $("input[name='num11']").val();
var num2 = $("input[name='num22']").val();
$.ajax({
url: '/calc/',
type: 'post',
data: {
num1: num1,
num2: num2,
csrfmiddlewaretoken: $('input[name="csrfmiddlewaretoken"]').val(),
},
success: function (ret) {
$("input[name='num33']").val(ret);
console.log(ret);
},
error: function (ret) {
console.log(ret);
}
});
});
```
```python
from django.shortcuts import render, HttpResponse
def calc(request):
if request.method == 'POST':
num1 = request.POST.get('num1')
num2 = request.POST.get('num2')
num3 = int(num1) + int(num2)
return HttpResponse(num3)
return render(request, 'calc.html')
```
###Ajax局部提交参数中含有数组(序列化和反序列化)
```html
<button id="btn1">Ajax测试</button>
```
```javascript
$("#btn1").click(function () {
$.ajax({
url: '/test/',
type: 'post',
headers:{"X-CSRFTOKEN": $.cookie('csrftoken')},
data: {
name: 'lily',
age: 18,
hobby: JSON.stringify(["爬山", "打羽毛球", "打乒乓球"])
},
success: function (ret) {
console.log(ret);
},
error: function (ret) {
console.log(ret);
}
});
});
```
```python
from django.http.response import JsonResponse
import json
def test(request):
if request.method == "POST":
name = request.POST.get('name')
age = request.POST.get('age')
hobby = json.loads(request.POST.get('hobby'))
print("name:", name, type(name)) # name: lily <class 'str'>
print("age:", age, type(age)) # age: 18 <class 'str'>
print("hobby:", hobby, type(hobby)) # hobby: ['爬山', '打羽毛球', '打乒乓球'] <class 'list'>
return JsonResponse({"status": "success", "code": 200})
```
###Ajax局部提交(参数中含有数组)
```html
<button id="btn2">Ajax测试2</button>
```
```javascript
$("#btn2").click(function () {
$.ajax({
url: '/test2/',
type: 'post',
data: {
name: 'lily',
age: 18,
hobby: ["爬山", "打羽毛球", "打乒乓球"]
},
success: function (ret) {
console.log(ret);
},
error: function (ret) {
console.log(ret);
}
});
});
```
```python
from django.http.response import JsonResponse
def test2(request):
if request.method == "POST":
name = request.POST.get('name')
age = request.POST.get('age')
hobby = request.POST.get('hobby')
hobby2 = request.POST.get('hobby[]')
hobby3 = request.POST.getlist('hobby[]')
print("name:", name, type(name)) # name: lily <class 'str'>
print("age:", age, type(age)) # age: 18 <class 'str'>
print("hobby:", hobby, type(hobby)) # hobby: None <class 'NoneType'>
print("hobby2:", hobby2, type(hobby2)) # hobby2: 打乒乓球 <class 'str'>
print("hobby3:", hobby3, type(hobby3)) # hobby3: ['爬山', '打羽毛球', '打乒乓球'] <class 'list'>
return JsonResponse({"status": "success", "code": 200})
```
###Ajax实现上传文件
```html
<input type="file" name="f1">
<button id="file_upload">上传</button>
```
```javascript
$("#file_upload").click(function () {
var form_data = new FormData();
form_data.append('f1', $("input[name='f1']")[0].files[0] );
$.ajax({
url: '/upload/',
type: 'post',
processData: false, //告诉Jquery不处理数据
contentType: false, //告诉Jquery不处理请求头信息
data: form_data,
success: function (ret) {
console.log(ret);
},
error: function (ret) {
console.log(ret);
}
});
});
```
```python
from django.http.response import render,JsonResponse
def upload(request):
if request.method == "POST":
file_obj = request.FILES.get('f1')
with open(file_obj.name, "wb") as f:
for con in file_obj:
f.write(con)
return JsonResponse({"status": "success", "code": 200})
return render(request, 'calc.html')
```
###form表单实现上传文件
```html
<form action="" method="post" enctype="multipart/form-data">
<input type="file" name="ff1">
<button>上传</button>
</form>
```
```python
from django.http.response import JsonResponse, render
def calc(request):
if request.method == "POST":
file_obj = request.FILES['ff1']
with open(file_obj.name, "wb") as f:
for con in file_obj:
f.write(con)
return JsonResponse({"status": "success", "code": 200})
return render(request, 'calc.html')
```
###局部开启csrf_token，只需要给视图函数添加csrf_protect装饰器
```python
from django.views.decorators.csrf import csrf_protect
@csrf_protect
def calc(request):
if request.method == "POST":
pass
```
###局部关闭csrf_token,只需要给视图函数添加csrf_exempt装饰器
```python
from django.views.decorators.csrf import csrf_exempt
@csrf_exempt
def calc(request):
if request.method == "POST":
pass
```
###强制设置cookie，只需要给视图函数增加ensure_csrf_cookie
```python
from django.views.decorators.csrf import ensure_csrf_cookie
@ensure_csrf_cookie
def calc(request):
if request.method == "POST":
pass
```