类视图的引入

以函数的形式进行定义的视图就是函数视图,视图函数便于理解,但是遇到一个视图函数对应的路径提供了多种不同的HTTP请求方式的支持时(get,post,delete,put),需要在一个函数中写不同的业务逻辑,代码的可读性和复用性就很底, 所以,我们引入类视图进行解决.

  1.  def register(request):
  5.     """处理注册"""
  13.     # 获取请求方法，判断是GET/POST请求
  17.     if request.method == 'GET':
  21.         # 处理GET请求，返回注册页面
  25.         return render(request, 'register.html')
  29.     else:
  33.         # 处理POST请求，实现注册逻辑
  37.         return HttpResponse('这里实现注册逻辑')

使用类视图讲不通的请求方式进行不同的方式进行区分定义:

  1. class DefineClassview(View):
  2.     """演示类视图的定义和使用"""
  4.     def get(self, request):
  5.         """处理GET请求业务逻辑"""
  6.         return HttpResponse('GET请求业务逻辑')
  8.     def post(self, request):
  9.         """处理POST请求业务逻辑"""
  10.         return HttpResponse('POST请求业务逻辑')
  12.     def put(self, request):
  13.         pass

类视图的优点:

  • 代码可读性好
  • 类视图相对于函数视图有更高的复用性,如果其他地方需要使用到某个类的某个特定方法,直接继承该类的视图就可以了

类视图的使用

定义类视图需要继承自的Django提供的父类的View

导入方法:

  1. from django.views.generic import View    
  2. 或 : from django.views.generic.base import View
  1. 配置路由时,需要使用类视图的as_view()方法来注册添加
  2. urlpatterns = [
  6.     # 视图函数：注册
  10.     # url(r'^register/$', views.register, name='register'),
  14.     # 类视图：注册  as_view()可以将类视图转换成视图,并决定如何分发请求
  18.     url(r'^register/$', views.RegisterView.as_view(), name='register'),
  22. ]

类视图使用装饰器

定义一个为函数视图准备的装饰器,和一个要被装饰的类视图

  1. def my_decorator(view_func):
  2.     """
  3.     定义装饰器，装饰类视图
  4.     :param view_func: 被装饰的视图函数
  5.     :return: wrapper，装饰的结果
  6.     """
  7.     def wrapper(request, *args, **kwargs):
  8.         print('装饰器被调用了')
  9.         print(request.method, request.path)
  11.         # 调用给装饰的视图函数
  12.         return view_func(request, *args, **kwargs)
  13.     return wrapper
  14. class DefineClassview(View):
  15.     """演示类视图的定义和使用"""
  17.     def get(self, request):
  18.         """处理GET请求业务逻辑"""
  19.         return HttpResponse('GET请求业务逻辑')
  21.     def post(self, request):
  22.         """处理POST请求业务逻辑"""
  23.         return HttpResponse('POST请求业务逻辑')
  25.     def put(self, request):
  26.         pass
  28. url(r'^define_classview/$',my_decorator(views.DefineClassview.as_view())),   #这种方法可以给类视图的所有方法添加装饰器功能
  29. @method_decorator(my_decorator, name='dispatch')  # 直接在类视图上面添加装饰器 同样可以实现给类视图的所有方法添加装饰器功能
  30. url(r'^define_classview/$', views.DefineClassview.as_view()),

method_decorator装饰器使用name参数指明被装饰的方法

为特定的请求方法添加装饰器:

如果需要为类视图的多个方法添加装饰器，但又不是所有的方法（为所有方法添加装饰器参考上面例子），可以直接在需要添加装饰器的方法上使用method_decorator，如下所示

  1. # 在不同的视图函数上添加装饰器，有的不需要
  2. class DefailView(View):
  3.     @method_decorator(my_decorator,name='get')
  4.     def get(self,request):
  5.         print('get方法')
  6.         return HttpResponse('get请求方法')
  8.     @method_decorator(my_decorator,name='post')
  9.     def post(self,request):
  10.         print('post方法')
  11.         return HttpResponse('post方法')
  13.     def put(self,request):
  14.         pass

类视图Mixin扩展类

使用面向对象多继承的特性，可以通过定义父类（作为扩展类），在父类中定义想要向类视图补充的方法，类视图继承这些扩展父类，便可实现代码复用。

定义的扩展父类名称通常以Mixin结尾。

  1. # 多继承  扩展Mixin
  2. class ListModelMixin(object):
  4.     def list(self,request,*args,**kwargs):
  5.         print('list视图函数被调用了')
  6.         return HttpResponse('list视图函数')
  8. class CreateModelMixin(object):
  10.     def create(self,request,*args,**kwargs):
  11.         print('create视图被调用了')
  12.         return HttpResponse('create视图')
  14. class BookView(CreateModelMixin,ListModelMixin,View):
  16.     def get(self,request):
  17.         self.list(request)
  18.         print('子类的get方法')
  19.         return HttpResponse('get方法')
  21.     def post(self,request):
  22.         self.create(request)
  23.         print('子类的post方法')
  24.         return HttpResponse('post方法')
  26. class SaveOrderView(CreateModelMixin,View):
  28.     def get(self,request):
  29.         self.create(request)
  30.         return HttpResponse('Save类')