django项目开发模拟auth的做一个登录验证(二)

上一章节我们实现了密码的加密解密与修改密码,本章讲述模拟auth封装登录、退出、装饰器、中间件、上下文的功能

一、封装登录的函数

• 1、导包(使用第二种加密方式的模块)

  from models import WebUserModel
  import configs

• 2、封装登录的方法

  
  # 封装登录的方法  
  
  def front_login(request, email, password):
      # 根据邮箱查询用户密码
      webUser = WebUserModel.objects.filter(email=email).first()
      if webUser:
          # 校验用户输入的密码是否正确
          result = webUser.check_password(password)
          if result:
              # 把当前用户的uid保存到request.session
              request.session[configs.LOGINED_KEY] = str(webUser.uid)
              return webUser
          else:
              return None
      else:
          return None

• 3、测试

  
  # 测试登录  
  
  def login(request):
      email = 'aab@qq.com'
      password = '123'
      result = front_login(request,email,password)
      print '*'*100
      print result
      print '*'*100
      if result:
          return render(request, 'login.html')
      else:
          return HttpResponse(u'login fail')

二、退出的封装

• 1、具体代码

  
  # 封装退出的方法
  
  def front_logout(request):
      try:
          del request.session[configs.LOGINED_KEY]
      except KeyError:
          pass

三、登录的装饰器

装饰器实际上就是一个函数,一个接收一个函数的柯理化函数

• 1、导包

  import configs
  from django.shortcuts import redirect, reverse

• 2、定义一个装饰器

  
  # 定义一个登录的装饰器  
  
  def front_login_required(func):
      def wrapper(request, *args, **kwargs):
          # 从request中获取登录时候存放的uid
          uid = request.session.get(configs.LOGINED_KEY)
          if uid:
              return func(request, *args, **kwargs)
          else:
              # 模仿auth的装饰器
              url = reverse(configs.FRONT_LOGIN) + '?next=' + request.path
              return redirect(url)
  
      return wrapper

• 3、使用

  from frontauth.decorators import front_login_required
  
  @front_login_required
  def index(request):
      return render(request,'index.html')

四、中间件

中间件是在request和view之间以及view和response之间做一些处理的

• 1、定义一个中间件

  from django.utils.deprecation import MiddlewareMixin
  from models import WebUserModel
  import configs
  
  
  
  # 定义一个前端的中间件
  
  class AuthFrontMiddleWare(MiddlewareMixin):
      # 处理view->request
      def process_request(self, request):
          # 1.从request中获取uid判断是否登录
          if request.session.get(configs.LOGINED_KEY):
              # 2.判断当前的request中是否已经添加了front_user
              if not hasattr(request, 'front_user'):
                  uid = request.session.get(configs.LOGINED_KEY)
                  webUser = WebUserModel.objects.filter(pk=uid).first()
                  setattr(request, 'front_user', webUser)
  
      # 处理view->response
      # def process_response(self, request,response):
      #    pass

• 2、在settings.py文件中注册

  MIDDLEWARE = [
      ...
      'frontauth.middlewares.AuthFrontMiddleWare', # 注册自己定义的中间件
  ]

• 3、测试

  def middleWares(request):
      if hasattr(request,'front_user'):
          print request.front_user
          return HttpResponse(u'已经有中间件front_user')
      else:
          return HttpResponse(u'还没有中间件front_user')

五、上下文处理器

上下文处理器返回的是一个字典(别的语言叫对象,这个是必须的)

• 1、定义一个上下文

  import configs
  from models import WebUserModel
  
  def FrontAuth(request):
      # 1.判断用户是否登录
      uid  = request.session.get(configs.LOGINED_KEY)
      if uid:
          if hasattr(request,'front_user'):
              return {'front_user':request.front_user}
          else:
              webUser = WebUserModel.objects.filter(pk=uid).first()
              return {'front_user': webUser}
      else:
          return {}

• 2、在settings.py文件中注册

  TEMPLATES = [
      {
          'BACKEND': 'django.template.backends.django.DjangoTemplates',
          'DIRS': [os.path.join(BASE_DIR, 'templates')]
          ,
          'APP_DIRS': True,
          'OPTIONS': {
              'context_processors': [
                  ...
                  'frontauth.contextProcessors.FrontAuth'
              ],
          },
      },
  ]

• 3、测试

  <h1>{{ front_user.email }}</h1>

六、总结对比中间件与上下文

• 1、相同点是定义了都需要在settings.py文件中注册
• 2、相同点是他们都有点类似定义了一个全局变量,在整个项目中都可以获取到
• 3、主要区别：中间件是使用在后端代码中使用,而上下文是在前端模板中使用
• 4、在现在前后端分离开发的情况下上下文有点类似前端的本地存储,在实际开发过程中已经不需要定义了,除非你还是使用的是前后端不彻底分离的开发模式才需要使用

七、代码下载地址传送门