jquery操作cookie
- 下载地址
http://plugins.jquery.com/cookie/
- 引入
<script type="text/javascript" src="js/jquery.min.js"></script>
<script type="text/javascript" src="js/jquery.cookie.js"></script>
- cookie操作
设置值：
$.cookie('the_cookie','the_value');
#设置7天有效期
$.cookie('the_cookie','the_value',{expires:7});
读取
$.cookie('the_cookie'); #通过键来取值
删除cookie
$.cookie('the_cookie',null); #通过传递null作为cookie的值即可
中间件
配置文件
项目主目录中的配置文件是django留给开发者使用的用户级别配置文件
实际上django有一个自己的默认全局配置文件
那么他们的关系如下
#django默认配置
from django.conf import global_settings
#用户级别配置
from django_middleware import settinigs
from django.conf import settings #中间人
#比如需要引入配置中的某个配置项settings.APPEND_SLASH,那么这样的引入的查找顺序是这样的，先去用户级别settings.py文件中找这个配置，如果没有找到，那么再去global_settings中去找默认配置
django请求生命周期
中间件用来对请求和响应做一些统一加工和处理的，比如对所有请求中的post请求做一个csrftoken认证，就用到了我们的'django.middleware.csrf.CsrfViewMiddleware'，后面视图中能够使用request.session做一个session相关操作，这个request.session的功能就是在这个中间件中加工好的'django.contrib.sessions.middleware.SessionMiddleware'
自定义中间件
- 登录认证、权限认证、频率访问限制、请求数据统计等等...
- 自定义中间的步骤
1.应用文件夹下面创建一个文件夹，名字随便起，比如叫作mymiddleware
2.在mymiddleware文件夹下面创建一个py文件，名称随意，比如叫做middlewares.py
3.在middlewares.py文件中写上如下内容
from django.utils.deprecation import MiddlewareMixin
class LoginAuth(MiddlewareMixin):
def process_request(self,request):
print('xxx')
4.settings.py配置文件中写上如下内容
MIDDLEWARE = [
....
'应用名.中间文件夹.中间文件.类'
'app01.mymiddleware.middlewares.LoginAuth', #配置中间件类，告诉django，我写的这个自定义中间件，你帮我使用上，一般都是放到最后，不然上面几个中间件的相关功能就没办法使用上了。
#如果中间件功能不想用了，就注释掉它就行了。
#以上几步搞定后，所有请求都会触发我们的中间件类中的process_request方法。
]
- 登录认证中间示例
中间件代码如下
#登录认证中间件
class LoginAuth(MiddlewareMixin):
#/login/登录请求，应该正常放行，让他能获得login.html页面
#添加一个白名单，这样首页登录就不需要登录认证
white_list = ['/login/',]
def process_request(self,request):
print('请求来啦！！！')
#获取当前请求路径:request.path /login/
#如果当前请求路径在白名单里面，我们不进行登录认证
if not request.path in self.white_list:
is_login = request.session.get('is_login') #True
if not is_login:
return redirect('/login/')
#视图代码
def login(request):
if request.method == 'GET':
return render(request,'login.html')
else:
#print('xxxxxx')
uname = request.POST.get('username')
if uname == 'root':
request.session['is_login'] = True
return redirect('/home/')#告诉浏览器向/home/发送get请求获取页面
else:
return redirect('/login/')
def home(request):
print('home')
return render(request,'home.html')
def index(request):
print('index')
return render(request,'index.html')
#执行步骤：如判断用户访问home页面，是否已经登录过了
第一次请求的时候，先是走的中间件process_request，login路径，在白名单里面，所以就不会走下面的判断，
实际后面会有个return None,就表示是正常返回，可以省略不用写，然后再去执行视图逻辑，获取到login页面，get请求获取login页面。
第二次填写数据发送post请求，又会走一遍process_request，正常返回后再去执行视图逻辑，后台获取发送来的数据，
设置session，然后重定向到home页面，重定向的时候又会走了一遍process_request,然后中间件会判断这个重定向的路径，最后再执行视图逻辑。
下次想直接访问home页面的时候，先是发送/home/请求，先走中间件process_request，判断当前的路径是不是在白名单里，
显然不在，然后执行下面的逻辑代码，获取到session中的键值对，如获取到了，return None,那么就会执行视图里面的逻辑，就直接执行home函数。
如没有获取到，那么直接在中间件代码里面直接就重定向到login页面。
中间件的五个方法
整个中间件的执行顺序
process_request从上到下，process_response从下到上
- 五个方法：process_request和process_response这个两个是重点
process_request(self,request) #请求
process_view(self,request,view_func,view_args,view_kwargs)#视图
process_template_response(self,request,response)#模板
process_exception(self,request,exception) #错误
process_response(self,request,response) #响应
每个方法的执行流程
- 1.process_request
class Md1(MiddlewareMixin):
def process_request(self,request):
print('MD1--process_request')
#当process_request返回时None，可以默认不写，那么才会继续执行后面的中间件的process_request,如果你是最后一个中间件，并且你返回的是None，那么逻辑会继续执行到我们的url路由控制器
#但是当process_request里面return的是一个HttpResponse对象，那么后面的中间件的process_request将不再执行，也不会走到url路由控制器
#return HttpResponse('中间件md1的逻辑，没有通过！！！')
class Md2(MiddlewareMixin):
def process_request(self,request):
print('MD1--process_request')
views.py代码
def home(request):
print('home')
return render(request,'home.html')
执行流程--中间件正常return None的情况:
MD1--process_request
MD2--process_request
home
执行流程--中间件Md1中响应回复对象的情况:
MD1--process_request
因为Md1中return的是响应对象，所以就不会再向下执行了，同时也不会去执行逻辑代码。
- 2.process_response
class Md1(MiddlewareMixin):
def process_request(self,request):
print('MD1--process_request')
def process_response(self,request,response):
:param request: 当前请求对象
:param response: 视图函数的响应对象
:return:
print('Md1--响应')
#可以对响应内容做统一处理，如加响应头
response['xx'] = 'oo'
print(response.content) #获取响应回复内容 #b'ok'
#注意，如果你写了process_response方法，那么这个方法必须return response
return response
class Md2(MiddlewareMixin):
def process_request(self,request,response):
print('MD2--process_request')
def process_response(self,request,response):
print('MD2--响应')
# if response.content != b'ok':
#如果process_response方法里面return了一个HttpResponse对象，那么这个对象会覆盖视图返回来的HttpResponse对象
#return HttpResponse('响应不OK!!!')
return response
views.py文件
def home(request):
print('home')
return render(request,'home.html')
#return HttpResponse('我是home响应')
执行流程 正常执行：
MD1--process_request #中间件请求从上至下
MD2--process_request
home #请求结束会后执行视图逻辑
MD2--process_response #中间响应从下至上
MD1--process_response
执行流程 中间件HttpResponse响应覆盖视图返回来的Httpresponse对象：
MD1--process_request #中间件请求从上至下
MD2--process_request
home #执行视图逻辑，响应我是home响应
MD2--process_response #中间件响应从下至上，覆盖视图响应对象响应不OK!!!
MD1--process_response
- 注意事项
当中间件1的process_request方法return的是一个HttpResponse，那么会执行中间件1的process_response方法，不会去执行中间件2的方法了
- 3.process_view(self,request,view_func,view_args,view_kwargs)
from django.shortcuts import render,redirect,HttpResponse
from django.utils.deprecation import MiddlewareMix
class Md1(MiddlewareMixin):
def process_request(self,request):
print('MD1--process_request')
def process_response(self,request,response):
print('MD1--process_response')
return response
def process_view(self,request,view_func,view_args,view_kwargs):
print('MD1--process_view')
class Md2(MiddlewareMixin):
def process_request(self,request):
print('MD2--process_request')
def process_response(self,request,response):
:param request:
:param view_func: 此次请求要执行的视图函数对象
:param view_args: 要函数的参数
:param view_kwargs: 要函数的参数
:return:
print('MD2--process_response')
return response
def process_view(self,request,view_func,view_args,view_kwargs):
print('MD2--process_view')
执行流程：
MD1--process_request #中间件请求从上至下
MD2--process_request
MD1--process_view #中间件视图从上至下
MD2--process_view
中间件2执行函数名称 home
home #逻辑视图
MD2--process_response #中间件响应 从下至上
MD1--process_response
-
process_view图解
-
4.process_exception(self,request,exception)
当视图函数出现错误或者异常时，自动触发的方法，能够捕获视图出现的错误，进行一些错误的统一处理
from django.shortcuts import render,redirect,HttpResponse
from django.utils.deprecation import MiddlewareMixin
class Md1(MiddlewareMixin):
def process_request(self,request):
print('MD1--process_request')
def process_response(self,request,response):
print('MD1--process_response')
return response
def process_view(self,request,view_func,view_args,view_kwargs):
print('MD1--process_view')
def process_exception(self,request,exception):
print('MD1--process_exception')
class Md2(MiddlewareMixin):
def process_request(self,request):
print('MD2--process_request')
def process_response(self,request,response):
print('MD2--process_response')
return response
def process_view(self,request,view_func,view_args,view_kwargs):
print('MD2--process_view')
def process_exception(self,request,exception):
from django.core.exceptions import PermissionDenied
# print('>>>>>>', exception, type(exception))
# if isinstance(exception,PermissionDenied):
# return HttpResponse('权限不够！！！！！')
#>>>>>> 权限不够 <class 'django.core.exceptions.PermissionDenied'>
# >>>>>> 出错啦！！！
print('MD2--process_exception')
views.py代码
from django.core.exceptions import PermissionDenied #为了演示错误
def home(request):
print('home')
raise PermissionDenied('权限不够')
return render(request,'home.html')
执行流程：
MD1--process_request #中间件请求从上至下
MD2--process_request
MD1--process_view #中间件视图从上至下
MD2--process_view
home #逻辑视图
MD2--process_exception #中间件错误从下至上
MD1--process_exception
MD2--process_response #中间件响应从下至上
MD1--process_response
-
process_exception图解
-
5.process_template_response(self,request,reponse)
from django.shortcuts import render,redirect,HttpResponse
from django.utils.deprecation import MiddlewareMixin
class Md1(MiddlewareMixin):
def process_request(self,request):
print('MD1--process_request')
def process_response(self,request,response):
print('MD1--process_response')
return response
def process_view(self,request,view_func,view_args,view_kwargs):
print('MD1--process_view')
def process_exception(self,request,exception):
print('MD1--process_view')
def process_template_response(self,request,response):
print('MD1--process_template_response')
return response
class Md2(MiddlewareMixin):
def process_request(self,request):
print('MD2--process_requeust')
def process_response(self,request,response):
print('MD2--process_response')
def process_view(self,request,view_func,view_args,view_kwargs):
print('MD2--process_view')
def process_exception(self,request,exception):
print('MD2--process_exception')
def process_template_response(self,request,response):
print('MD2--process_template_response')
return response
views.py代码
def home(request):
print('home')
def render():
print('你好render')
return HttpResponse('你好response')
ret = HttpResponse('ojbk')
#必须给HttpResponse对象封装一个render属性等于一个render函数，才能触发中间件里面的process_template_response方法
ret.render = render
return ret
执行流程：
MD1--process_request #中间件请求从上至下
MD2--process_request
MD1--process_view #中间件视图从上至下
MD2--process_view
home #视图逻辑
MD2--process_template_response #中间件模板 从下至上
MD1--process_template_response
你好render #视图逻辑里面的render()函数中响应对象
MD2--process_response #中间件响应 从下至上
MD1--process_response
总结下中间件执行流程
请求到达中间件之后，先按照正序执行每个注册中间件的process_reques方法，process_request方法返回的值是None，
就依次执行，如果返回的值是HttpResponse对象，不再执行后面的process_request方法，而是执行当前对应中间件的process_response方法，
将HttpResponse对象返回给浏览器。也就是说：如果MIDDLEWARE中注册了6个中间件，执行过程中，第3个中间件返回了一个HttpResponse对象，
那么第4,5,6中间件的process_request和process_response方法都不执行，顺序执行3,2,1中间件的process_response方法。
process_request方法都执行完后，匹配路由，找到要执行的视图函数，先不执行视图函数，先执行中间件中的process_view方法，
process_view方法返回None，继续按顺序执行，所有process_view方法执行完后执行视图函数。加入中间件3 的process_view方法返回了HttpResponse对象，
则4,5,6的process_view以及视图函数都不执行，直接从最后一个中间件，也就是中间件6的process_response方法开始倒序执行。
url路由系统补充---include路由分发和命名空间 namespace
- 1.创建app
python manage.py startapp app01
- 2.配置app，在settings.py文件中
INSTALLED_APPS = [
...
'app02',
]
路由分发步骤
- 1.在项目主目录下的urls.py(以后我们称之为总路由)文件中,写上如下内容
from django.conf.urls import url,inclue
from django.contrib import admin
#路由分发功能
urlpatterns = [
url(r'^admin/',admin.site.urls),
url(r'^app01/',include('app01.urls')),#include参数格式'应用名称.urls'
url(r'^app02/',include('appo2.urls')),
#/app01/index/ 先在总路由中匹配前面的路径,然后匹配到了，拿剩下的index/，去app01应用下面的urls.py文件进行路径匹配
]
- 2.在每个应用文件夹下面创建一个ursl.py文件，里面内容
from django.conf.urls import url,include
from app01 import views
urlpatterns = [
url(r'^index/',views.index),
]
问题，当两个应用中的url的别名相同了，使用反向解析的时候该怎么解决
app01的urls.py
from django.conf.urls import url,include
from app01 import views
urlpatterns = [
url(r'^index/',views.index),
url(r'^home/',views.home,name='home'),
]
app02下的urls.py
from django.conf.urls import url,include
from app02 import views
urlpatterns = [
url(r'^index/',views.index),
url(r'^home/',views.home,name='home'),
]
app01的views.py文件进行别名解析
def index(request):
print('app01>>>',reverse('home'))
return HttpResponse('app01-index')
app02的views.py文件进行别名解析
def index(request):
print('app02>>>',reverse('home'))
return HttpResponse('app02-index')
以上执行完后，发现别名冲突，导致反向解析出错了
解决办法，用命名空间
总路由写法
from django.conf.urls import url,include
from django.contrib import admin
#路由分发
urlpatterns = [
url(r'^app01/',include('app01.urls',namespace='app01')),
url(r'^app02/',include('app02.urls',namespace='app02')),
]
app01视图写法
def index(request):
print('app01>>>',reverse('app01:home'))
return HttpResponse('app01-index')
app02视图写法
def index(request):
print('app02>>',reverse('app02:home'))
return HttpResponse('app02-index')
模板中使用
{% url 'app01:home' %}
路由分发如何设置首页
如果我们想通过输入http://127.0.0.1:8000/app01/,看到app01这个应用的首页，怎么办？就像现在输入一个http://127.0.0.1:8000来查看网站的首页，怎么办？
url(r'^$', views.index),#以空开头，还要以空结尾，写在项目的urls.py文件里面就是项目的首页，写在应用文件夹里面的urls.py文件中，那就是app01的首页
整个完整请求-中间件-后台逻辑处理的过程
