CBV加装饰器
基于session实现登录
1def login(request): 2 if request.method == 'POST': 3 username = request.POST.get('username') 4 pwd = request.POST.get('password') 5 if username=='jason' and pwd=='123': 6 request.session['name'] = 'jason' # 这一步是添加session 7 return redirect('/home/') 8 return render(request,'login.html')
如果说后面我们遇到了多个页面这些操作，都要实现校验，那么就得用到了装饰器，给类添加装饰器怎么添加？
装饰器
1from functools import wraps 2def login_auth(func): 3 @wraps(func) 4 def inner(request,*args,**kwargs): 5 if request.session.get('name'): 6 return func(request,*args,**kwargs) 7 return redirect('/login') 8 return inner
类添加装饰器
1# 给CBV添加装饰器的方法 2''' 31.第一种直接再类上面，必须指定name参数 42.直接再类里面的函数添加 53.重写dispatch方法 64.前端action里面修改路由 7''' 8# @method_decorator(login_auth,name='get') # 第一种 9class Myhome(View): 10 @method_decorator(login_auth) # 第三种 只要是总路由里面的都可以被装饰 11 def dispatch(self, request, *args, **kwargs): 12 super().dispatch(request,*args,**kwargs) 13 14 # @method_decorator(login_auth) # 第二种 15 def get(self,request): 16 return HttpResponse('get') 17 18 def post(self,request): 19 return HttpResponse('post')
django中间件
django请求生命周期
django中间件（django门户）
什么是中间件？
官方的说法：中间件是一个用来处理Django的请求和响应的框架级别的钩子。它是一个轻量、低级别的插件系统，用于在全局范围内改变Django的输入和输出。每个中间件组件都负责做一些特定的功能。
但是由于其影响的是全局，所以需要谨慎使用，使用不当会影响性能。
说的直白一点中间件是帮助我们在视图函数执行之前和执行之后都可以做一些额外的操作，它本质上就是一个自定义类，类中定义了几个方法，Django框架会在请求的特定的时间去执行这些方法。
我们一直都在使用中间件，只是没有注意到而已，打开Django项目的Settings.py文件，看到下图的MIDDLEWARE配置项。
1MIDDLEWARE = [ 2 'django.middleware.security.SecurityMiddleware', 3 'django.contrib.sessions.middleware.SessionMiddleware', 4 'django.middleware.common.CommonMiddleware', 5 'django.middleware.csrf.CsrfViewMiddleware', 6 'django.contrib.auth.middleware.AuthenticationMiddleware', 7 'django.contrib.messages.middleware.MessageMiddleware', 8 'django.middleware.clickjacking.XFrameOptionsMiddleware', 9]
MIDDLEWARE配置项是一个列表(列表是有序的)，列表中是一个个字符串，这些字符串其实是一个个类，也就是一个个中间件。django默认有七个中间件，但是django暴露给用户可以自定义中间件并且里面可以写五种方法
请求来了之后会依次经过每一个门户，才会到urls.py
查看具体方法
1class SecurityMiddleware(MiddlewareMixin): 2 def __init__(self, get_response=None): 3 self.sts_seconds = settings.SECURE_HSTS_SECONDS 4 self.sts_include_subdomains = settings.SECURE_HSTS_INCLUDE_SUBDOMAINS 5 self.sts_preload = settings.SECURE_HSTS_PRELOAD 6 self.content_type_nosniff = settings.SECURE_CONTENT_TYPE_NOSNIFF 7 self.xss_filter = settings.SECURE_BROWSER_XSS_FILTER 8 self.redirect = settings.SECURE_SSL_REDIRECT 9 self.redirect_host = settings.SECURE_SSL_HOST 10 self.redirect_exempt = [re.compile(r) for r in settings.SECURE_REDIRECT_EXEMPT] 11 self.get_response = get_response 12 13 def process_request(self, request): 14 path = request.path.lstrip("/") 15 if (self.redirect and not request.is_secure() and 16 not any(pattern.search(path) 17 for pattern in self.redirect_exempt)): 18 host = self.redirect_host or request.get_host() 19 return HttpResponsePermanentRedirect( 20 "https://%s%s" % (host, request.get_full_path()) 21 ) 22 23 def process_response(self, request, response): 24 if (self.sts_seconds and request.is_secure() and 25 'strict-transport-security' not in response): 26 sts_header = "max-age=%s" % self.sts_seconds 27 if self.sts_include_subdomains: 28 sts_header = sts_header + "; includeSubDomains" 29 if self.sts_preload: 30 sts_header = sts_header + "; preload" 31 response["strict-transport-security"] = sts_header 32 33 if self.content_type_nosniff and 'x-content-type-options' not in response: 34 response["x-content-type-options"] = "nosniff" 35 36 if self.xss_filter and 'x-xss-protection' not in response: 37 response["x-xss-protection"] = "1; mode=block" 38 39 return response
具体代码
ps:
1.请求来的时候会依次执行每一个中间件里面的process_request方法，如果没有直接通过
2.响应走的时候会依次执行每一个中间件里面的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)
以上方法的返回值可以是None或一个HttpResponse对象，如果是None，则继续按照django定义的规则向后继续执行，如果是HttpResponse对象，则直接将该对象返回给用户。
自定义一个中间件示例
新建一个任意名字的文件夹，里面新建一个任意名字的文件夹
中间件本质就是含有5个可以修改的内置方法的类，所以自定义的时候需要做的就是先继承一个Django提供的中间件混合父类--MiddlewareMixin
然后记得去settings中配置中间件
请求来了之后会依次往下走
请求走的时候也是从下往上依次执行，但是我们要知道的是，django中说你在当前这个中间件中的process_request中返回了HttpResponse的话，会直接走这个中间件的response方法，直接按照这个中间件的顺序从下往上返回信息。
具体信息查看
注意：如果你的自定义process_response不返回一个return response的话，会直接报错
报错信息是
在自定义的中间件中process_response返回了response
process_request
process_request有一个参数，就是request，这个request和视图函数中的request是一样的(在交给Django后面的路由之前，对这个request对象可以进行一系列的操作)。
由于request对象是一样的，所以我们可以对request对象进行一系列的操作，包括request.变量名=变量值,这样的操作，我们可以在后续的视图函数中通过相同的方式即可获取到我们在中间件中设置的值。
它的返回值可以是None也可以是HttpResponse对象。返回值是None的话，按正常流程继续走，交给下一个中间件处理，如果是HttpResponse对象，Django将不执行视图函数，而将相应对象返回给浏览器。
我们来看看多个中间件时，Django是如何执行其中的process_request方法的。
1class Mymiddlewera(MiddlewareMixin): 2 def process_request(self,request): 3 print('我是app02中mymiddlewera中第一个自定义的中间件方法请求方法') 4 5 6class Mymiddlewera2(MiddlewareMixin): 7 def process_request(self,request): 8 print('我是app02中mymiddlewera中第二个自定义的中间件方法请求方法')
settings中配置
1MIDDLEWARE = [ 2 'django.middleware.security.SecurityMiddleware', 3 'django.contrib.sessions.middleware.SessionMiddleware', 4 'django.middleware.common.CommonMiddleware', 5 # 'django.middleware.csrf.CsrfViewMiddleware', 6 'django.contrib.auth.middleware.AuthenticationMiddleware', 7 'django.contrib.messages.middleware.MessageMiddleware', 8 'django.middleware.clickjacking.XFrameOptionsMiddleware', 9 'app02.mymiddlewera.middle.Mymiddlewera', # 自定义中间件1 10 'app02.mymiddlewera.middle.Mymiddlewera2' # 自定义中间件2 11]
通过终端打印，我们发现中间件是自上而下依次执行
然后我们调换一下位置
在打印一下两个自定义中间件中process_request方法中的request参数，会发现它们是同一个对象。
总结：
由此总结一下：
- 中间件的process_request方法是在执行视图函数之前执行的。
- 当配置多个中间件时，会按照MIDDLEWARE中的注册顺序，也就是列表的索引值，从前到后依次执行的。
- 不同中间件之间传递的request都是同一个对象
process_response
多个中间件中的process_response方法是按照MIDDLEWARE中的注册顺序倒序执行的，也就是说第一个中间件的process_request方法首先执行，而它的process_response方法最后执行，最后一个中间件的process_request方法最后一个执行，它的process_response方法是最先执行。
定义process_response方法时，必须给方法传入两个形参，request和response。request就是上述例子中一样的对象，response是视图函数返回的HttpResponse对象(也就是说这是Django后台处理完之后给出一个的一个具体的视图)。该方法的返回值(必须要有返回值)也必须是HttpResponse对象。如果不返回response而返回其他对象，则浏览器不会拿到Django后台给他的视图
通过我们上面的代码和图片演示，我们直接进行总结
总结：
process_response方法是在视图函数之后执行的，并且顺序是从下往上依次执行。
多个中间件中的process_response方法是按照MIDDLEWARE中的注册顺序倒序执行的，也就是说第一个中间件的process_request方法首先执行，而它的process_response方法最后执行，最后一个中间件的process_request方法最后一个执行，它的process_response方法是最先执行。
process_view
process_view(self, request, view_func, view_args, view_kwargs)
该方法有四个参数
request是HttpRequest对象。
view_func是Django即将使用的视图函数。 （它是实际的函数对象，而不是函数的名称作为字符串。）
view_args是将传递给视图的位置参数的列表.
view_kwargs是将传递给视图的关键字参数的字典。 view_args和view_kwargs都不包含第一个视图参数（request）。
Django会在调用视图函数之前调用process_view方法。
它应该返回None或一个HttpResponse对象。 如果返回None，Django将继续处理这个请求，执行任何其他中间件的process_view方法，然后在执行相应的视图。 如果它返回一个HttpResponse对象，那么将不会执行Django的视图函数，而是直接在中间件中掉头，倒叙执行一个个process_response方法，最后返回给浏览器
1class Mymiddlewera(MiddlewareMixin): 2 def process_request(self,request): 3 print('我是app02中mymiddlewera中第一个自定义的中间件方法请求方法') 4 print('111',request) 5 # return HttpResponse('好想好好的睡个一夜直到天亮') 6 7 def process_response(self,requset,response): 8 print('我是app02中mymiddlewera中第一个自定义的中间件方法响应方法') 9 return response # 必须将response接收到的数据返回，不然报错 10 11 def process_view(self,request,view_func,view_args,view_kwargs): 12 print('111,你说啥就是啥吧') 13 print(view_func) 14 print(view_args) 15 print(view_kwargs)
终端打印结果
process_view方法是在Django路由系统之后，视图系统之前执行的，执行顺序按照MIDDLEWARE中的注册顺序从前到后顺序执行的
process_exception
process_exception(self, request, exception)
该方法两个参数:
一个HttpRequest对象
一个exception是视图函数异常产生的Exception对象。
这个方法只有在视图函数中出现异常了才执行，它返回的值可以是一个None也可以是一个HttpResponse对象。如果是HttpResponse对象，Django将调用模板和中间件中的process_response方法，并返回给浏览器，否则将默认处理异常。如果返回一个None，则交给下一个中间件的process_exception方法来处理异常。它的执行顺序也是按照中间件注册顺序的倒序执行。
1class Mymiddlewera(MiddlewareMixin): 2 def process_request(self,request): 3 print('我是app02中mymiddlewera中第一个自定义的中间件方法请求方法') 4 print('111',request) 5 # return HttpResponse('好想好好的睡个一夜直到天亮') 6 7 def process_response(self,requset,response): 8 print('我是app02中mymiddlewera中第一个自定义的中间件方法响应方法') 9 return response # 必须将response接收到的数据返回，不然报错 10 11 def process_view(self,request,view_func,view_args,view_kwargs): 12 print('111,你说啥就是啥吧') 13 print(view_func) 14 print(view_args) 15 print(view_kwargs) 16 17 18 def process_exception(self,request,exception): 19 print('222,你可真烦人啊！') 20 print(exception)
process_template_response（用的比较少）
process_template_response(self, request, response)
它的参数，一个HttpRequest对象，response是TemplateResponse对象（由视图函数或者中间件产生）。
process_template_response是在视图函数执行完成后立即执行，但是它有一个前提条件，那就是视图函数返回的对象有一个render()方法（或者表明该对象是一个TemplateResponse对象或等价方法）。
1class Mymiddlewera(MiddlewareMixin): 2 def process_request(self,request): 3 print('我是app02中mymiddlewera中第一个自定义的中间件方法请求方法') 4 print('111',request) 5 # return HttpResponse('好想好好的睡个一夜直到天亮') 6 7 def process_response(self,requset,response): 8 print('我是app02中mymiddlewera中第一个自定义的中间件方法响应方法') 9 return response # 必须将response接收到的数据返回，不然报错 10 11 def process_view(self,request,view_func,view_args,view_kwargs): 12 print('111,你说啥就是啥吧') 13 print(view_func) 14 print(view_args) 15 print(view_kwargs) 16 17 18 def process_exception(self,request,exception): 19 print('222,你可真烦人啊！') 20 print(exception) 21 22 23 def process_template_response(self,request,response): 24 print('我是app02中的mymiddlewera中第一个自定义的render方法') 25 return response
views.py
1def index(request): 2 print('我是index，哈哈哈哈') 3 # print(request.method) 4 5 def render(): 6 print('567890') 7 # return 123 8 return HttpResponse('haodezhidaole ') 9 obj = HttpResponse('ok') 10 # print(1111) 11 obj.render=render # 这一步实际上触发了process 12 13 return obj
视图函数执行完之后，立即执行了中间件的process_template_response方法，顺序是倒序，先执行MD1的，在执行MD2的，接着执行了视图函数返回的HttpResponse对象的render方法，返回了一个新的HttpResponse对象，接着执行中间件的process_response方法。
总结：
process_request:请求来的时候从下往上依次执行每一个中间件里面的process_request
process_response:响应走的时候会从下往上依次执行执行每一个中间件的process_response方法
process_view：路由匹配成功，执行视图函数之前自动触发(顺序是从上往下依次执行)，view_func是执行视图函数的名字
process_exception:当视图函数出现报错，会自动触发，顺序是依次往下往上执行
process_template_response:当你返回对象的时候有一个render()方法的时候会触发，执行顺序从下往上依次执行
***************
django中渐渐暗能够帮我实现 网站全局的身份验证，黑名单，白名单，访问频率限制，反爬相关等等
》》》：django用来帮你做全局相关的功能校验
RBAC：基于角色的权限管理(不同的客户可以给出不同的访问权限)
所以后面只要是涉及到了全局相关，我们就可以直接再中间件这里进行操作，比如说去数据库中进行校验这个用户权限，然后只对他开放特定的功能块儿！
跨站请求伪造(CSRF)
钓鱼网站就是建一个和正常的网站一模一样的网站，然后用户在输入的时候调的也是正常网站的接口去处理，所以用户的钱会扣掉，但是并没有转给指定的人，其实就是建了一个和正常网站一模一样的东西，然后偷偷的在转给目标用户那里，偷偷的将input框当前的name去掉，然后用了一个hidden隐藏起来，在隐藏起来的input框中给一个默认的value，具体示例如下
模拟钓鱼网站示例
正常网站 views.py
1def transfer(request): 2 if request.method == 'POST': 3 username = request.POST.get('name') 4 money = request.POST.get('money') 5 others = request.POST.get('others') 6 print('%s 给 %s 转了 %s块钱'%(username,others,money)) 7 return render(request,'transfer.html')
正常网站transfer.html
1<!DOCTYPE html> 2<html lang="en"> 3<head> 4 <meta charset="UTF-8"> 5 <title>Title</title> 6 <script src="https://cdn.bootcss.com/jquery/3.4.1/jquery.min.js"></script> 7 <link rel="stylesheet" href="/static/bootstrap-3.3.7-dist/css/bootstrap.min.css"> 8 <script src="/static/bootstrap-3.3.7-dist/js/bootstrap.min.js"></script> 9</head> 10<body> 11<h1>正经网站</h1> 12<form action="" method="post"> 13 <p>name:<input type="text" name="name"></p> 14 <p>money:<input type="text" name="money"></p> 15 <p>others:<input type="text" name="others"></p> 16 <input type="submit"> 17</form> 18</body> 19</html>
钓鱼网站 transfer.html
1<!DOCTYPE html> 2<html lang="en"> 3<head> 4 <meta charset="UTF-8"> 5 <title>Title</title> 6 <script src="https://cdn.bootcss.com/jquery/3.4.1/jquery.min.js"></script> 7 <link rel="stylesheet" href="/static/bootstrap-3.3.7-dist/css/bootstrap.min.css"> 8 <script src="/static/bootstrap-3.3.7-dist/js/bootstrap.min.js"></script> 9</head> 10<body> 11<h1>钓鱼网站</h1> 12<form action="http://127.0.0.1:8000/transfer" method="post"> 13 <p>name:<input type="text" name="name"></p> 14 <p>money:<input type="text" name="money"></p> 15 <p>others: 16 <input type="text" > 17 <input type="hidden" name="others" value="mcc" style="display: none" > 18 </p> 19 <input type="submit"> 20</form> 21</body> 22</html>
这样就是最开始的网络诈骗ヽ(*。>Д<)o゜ヽ(*。>Д<)o゜
那我们学习了以后，如何保证我们的网站的安全呢？🤭🤭🤭，这个时候我们就想到了我们刚开始学习让注册掉的那个
django.middleware.csrf.CsrfViewMiddleware
中间件，他就是用来做校验的，他会每次都会在页面动态刷新生成一个value，然后每次用key值来比对这个value，通过了才会做下一步操作，不然的话就会直接拒绝这个请求，写法也很简单
form表单写法
我们直接在form表单中写{% csrf token%}，这个时候，django的中间件就会自动的帮我们去校验，他会每次都动态的生成一个验证码，只要页面刷新验证码就会不同，具体如下
1<!DOCTYPE html> 2<html lang="en"> 3<head> 4 <meta charset="UTF-8"> 5 <title>Title</title> 6 <script src="https://cdn.bootcss.com/jquery/3.4.1/jquery.min.js"></script> 7 <link rel="stylesheet" href="/static/bootstrap-3.3.7-dist/css/bootstrap.min.css"> 8 <script src="/static/bootstrap-3.3.7-dist/js/bootstrap.min.js"></script> 9</head> 10<body> 11<h1>正经网站</h1> 12<form action="" method="post"> 13 {% csrf_token %} 14 <p>name:<input type="text" name="name"></p> 15 <p>money:<input type="text" name="money"></p> 16 <p>others:<input type="text" name="others"></p> 17 <input type="submit"> 18</form> 19</body> 20</html>
这样的话，钓鱼网站怎么也访问不了
让你再骗人，😕😕😕
具体做法看图
每次这个value都会刷新，这样的话钓鱼网站怎么也访问不了
Ajax校验
这个中间件这么神奇，但是我们中间也有一些函数不想校验，具体做法如下
from django.views.decorators.csrf import csrf_exempt,csrf_protect
FBV校验
单个视图函数取消校验
1@csrf_exempt 2def index(request): 3 pass
单个函数添加校验
1@csrf_protect 2def login(request): 3 pass
CBV校验
1from django.utils.decorators import method_decorator 2from django.views.decorators.csrf import csrf_exempt,csrf_protect
单个类添加校验
三种方法都可以用,和正常的CBV装饰器方法一样
单个类取消校验
给CBV取消单个校验（csrf-exempt）
不能给单独的视图函数添加，只有dispatch可以，是因为给全局加的
直接给类加的，就要指定name='dispatch'
总结：其实都是给dispatch加，类就是一个路由，里面不可以单独写， --全部都要加到全局才可以
1@method_decorator(csrf_exempt,name='dispatch') # 第一种 2class Csrf_Token(View): 3 @method_decorator(csrf_exempt) # 第二种 4 def dispatch(self,request,*args,**kwargs): 5 res = super().dispatch(request,*args,**kwargs) 6 return res 7 @method_decorator(csrf_exempt) # 这里这么写不行！！！ 8 def get(self,request): 9 pass 10 def post(self,request): 11 pass
Auth认证模块
什么是Auth模块
Auth模块是Django自带的用户认证模块：
我们在开发一个网站的时候，无可避免的需要设计实现网站的用户系统。此时我们需要实现包括用户注册、用户登录、用户认证、注销、修改密码等功能，这还真是个麻烦的事情呢。
Django作为一个完美主义者的终极框架，当然也会想到用户的这些痛点。它内置了强大的用户认证系统--auth，它默认使用 auth_user 表来存储用户数据。
Auth模块常用的方法
from django.contrib import auth
authenticate()
提供了用户认证功能，即验证用户名以及密码是否正确，一般需要username 、password两个关键字参数。
如果认证成功（用户名和密码正确有效），便会返回一个 User 对象。
authenticate()会在该 User 对象上设置一个属性来标识后端已经认证了该用户，且该信息在后续的登录过程中是需要的。
用法：
user = authenticate(username='usernamer',password='password')
login(HttpRequest, user)
该函数接受一个HttpRequest对象，以及一个经过认证的User对象。
该函数实现一个用户登录的功能。它本质上会在后端为该用户生成相关session数据。
用法：
1from django.contrib.auth import authenticate, login 2 3def my_view(request): 4 username = request.POST['username'] 5 password = request.POST['password'] 6 user = authenticate(username=username, password=password) 7 if user is not None: 8 login(request, user) 9 # Redirect to a success page. 10 ... 11 else: 12 # Return an 'invalid login' error message. 13 ...
logout(request)
该函数接受一个HttpRequest对象，无返回值。
当调用该函数时，当前请求的session信息会全部清除。该用户即使没有登录，使用该函数也不会报错。
用法：
1from django.contrib.auth import logout 2 3def logout_view(request): 4 logout(request) 5 # Redirect to a success page.
is_authenticated()
用来判断当前请求是否通过了认证。
1def my_view(request): 2 if not request.user.is_authenticated(): 3 return redirect('%s?next=%s' % (settings.LOGIN_URL, request.path))
login_requierd()
auth 给我们提供的一个装饰器工具，用来快捷的给某个视图添加登录校验。
用法：
1from django.contrib.auth.decorators import login_required 2 3@login_required 4def my_view(request): 5 ...
若用户没有登录，则会跳转到django默认的 登录URL '/accounts/login/ ' 并传递当前访问url的绝对路径 (登陆成功后，会重定向到该路径)。
如果需要自定义登录的URL，则需要在settings.py文件中通过LOGIN_URL进行修改。
示例：
LOGIN_URL = '/login/' # 这里配置成你项目登录页面的路由
create_user()
auth 提供的一个创建新用户的方法，需要提供必要参数（username、password）等。
用法：
1from django.contrib.auth.models import User 2user = User.objects.create_user（username='用户名',password='密码',email='邮箱',...）
create_superuser()
auth 提供的一个创建新的超级用户的方法，需要提供必要参数（username、password）等。
用法：
1from django.contrib.auth.models import User 2user = User.objects.create_superuser（username='用户名',password='密码',email='邮箱',...）
check_password(password)
auth 提供的一个检查密码是否正确的方法，需要提供当前请求用户的密码。
密码正确返回True，否则返回False。
用法：
ok = user.check_password('密码')
set_password(password)
auth 提供的一个修改密码的方法，接收 要设置的新密码 作为参数。
注意：设置完一定要调用用户对象的save方法！！！
用法：
1user.set_password(password='') 2user.save()
User对象的属性
User对象属性：username， password
is_staff ： 用户是否拥有网站的管理权限.
is_active ： 是否允许用户登录, 设置为 False，可以在不删除用户的前提下禁止用户登录。
拓展auth_user表
这内置的认证系统这么好用，但是auth_user表字段都是固定的那几个，我在项目中没法拿来直接使用啊！
比如，我想要加一个存储用户手机号的字段，怎么办？
聪明的你可能会想到新建另外一张表然后通过一对一和内置的auth_user表关联，这样虽然能满足要求但是有没有更好的实现方式呢？
答案是当然有了。
我们可以通过继承内置的 AbstractUser 类，来定义一个自己的Model类。
这样既能根据项目需求灵活的设计用户表，又能使用Django强大的认证系统了。
1from django.contrib.auth.models import AbstractUser 2class UserInfo(AbstractUser): 3 """ 4 用户信息表 5 """ 6 nid = models.AutoField(primary_key=True) 7 phone = models.CharField(max_length=11, null=True, unique=True) 8 9 def __str__(self): 10 return self.username
注意：
按上面的方式扩展了内置的auth_user表之后，一定要在settings.py中告诉Django，我现在使用我新定义的UserInfo表来做用户认证。写法如下：
1# 引用Django自带的User表，继承使用时需要设置 2AUTH_USER_MODEL = "app名.UserInfo"
再次注意：
一旦我们指定了新的认证系统所使用的表，我们就需要重新在数据库中创建该表，而不能继续使用原来默认的auth_user表了。