def基本类 自动化路由 以及action装饰器

今日内容总结

九个视图子类

# 两个视图基类
# 五个视图扩展类
# 九个视图子类 --->视图类，不需要额外继承GenericAPIView，只需要继承九个中其中某个，就会有某个或某几个接口

# url
urlpatterns = [
    path('books/',views.BookView.as_view()),
    path('books/<int:pk>/',views.BookView.as_view()),
]

# views
class BookView(ListCreateAPIView):	# 查询所有 新增一个
    queryset = Book.objects.all()
    serializer_class = BookSerializer
  
# 新增一个 修改一个 删除一个
class BookDetaiView(RetrieveUpdateDestroyAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerializer
    
"""
1 ListAPIView,CreateAPIView
2 ListAPIView+CreateAPIView=ListCreateAPIView  给BookView用的
3 RetrieveAPIView,DestroyAPIView,UpdateAPIView
4 RetrieveDestroyAPIView,RetrieveUpdateAPIView                发现Destroy和Update的组合没有，就是没有提供，猜测，必须先查出来，再修改或删除，所以它没有
5 RetrieveUpdateDestroyAPIView 
"""

视图集

1.通过ModelViewSer编写五个接口

# url
urlpatterns = [
    path('books/',views.BookView.as_view({'get':'list', 'post':'create'})),
    path('books/<int:pk>/',views.BookView.as_view({'get': 'retrieve','put':'update','delete':'destroy'})),
]

# views
class BookView(ModelViewSet):	# 查询所有 新增一个
    queryset = Book.objects.all()
    serializer_class = BookSerializer
    
"""
当有类继承了ModelViewSet 那么五个接口都有了 但是要注意路由的写法
重点:
	变成.as_view({'get': 'list'}) 路由做映射，意思是如果get请求，访问这个地址，就执行视图类的list方法
"""

2.通过ReadOnlyModelViewSet编写两个只读接口

# url
urlpatterns = [
    path('books/',views.BookView.as_view({'get':'list'})),
    path('books/<int:pk>/',views.BookView.as_view({'get': 'retrieve'})),
]

# views
class BookView(ReadOnlyModelViewSet):	# 查询所有 新增一个
    queryset = Book.objects.all()
    serializer_class = BookSerializer

3.ViewSetMixin源码分析（路由改变的原因）

# 请求来了 路由匹配成功 ---> get请求 匹配成功books, 会执行 views.BookView.as_view({'get':'list','post':'create'})()     -注: as_views是ViewSetMixin的as_view

@classonlymethod
def as_view(cls, actions=None,**initkwargs):
    # 如果没u有传actions,直接抛异常,路由写法变了之后,as_view中不传字典 直接报错
    if not actions:
        raise TypeError("The `actions` argument must be provided when ""calling `.as_view()` on a ViewSet. For example ""`.as_view({'get': 'list'})`")
	def view(request,*args,**kwargs):
        self = cls(**inikwargs)
        if 'get' in actions and 'head' not in actions:
                actions['head'] = actions['get']
            self.action_map = actions
            for method, action in actions.items():
                handler = getattr(self, action)
                setattr(self, method, handler)

            return self.dispatch(request, *args, **kwargs)
        #  目的:去除了csrf校验
        return csrf_exempt(view)
    
# 路由匹配成功执行views.BookView.as_view({'get':'list', 'post':'create'})()---> 本质就是执行ViewSetMixin 的as_view内的 view()

view()部分代码
def view(request, *args, **kwargs):
	#actions 是传入的字典--->{'get': 'list', 'post': 'create'}
	self.action_map = actions
	# 第一次循环：method：get，action:list
	# 第一次循环：method：post，action:create
	for method, action in actions.items():
	# 反射：去视图类中反射，action对应的方法，action第一次是list，去视图类中反射list方法
	# handler就是视图类中的list方法
	handler = getattr(self, action)
	# 反射修改：把method：get请求方法，handler：list
	# 视图类的对象的get方法，变成了list
	setattr(self, method, handler)
	return self.dispatch(request, *args, **kwargs) #dispatch是APIView的

# 总结:
    -1.继承ViewSetMixin的视图类 路由写法就变了(重写了as_view)
    -2.变成需要传入字典映射方法:{'get':'list','post':'create'}
    	-只要传入actions 以后访问get就是访问list
    -3.其他执行跟之前一样
    -4.以后视图类 类中的方法名 可以任意命名 只要在路由中做好映射即可【重要】

4.from rest_framework.viewsets包下的类

"""
from rest_framwork.viewets下有这几个类
ModelViewSet:五个视图类+ViewSetxin+GenericAPIVIew
ReadOnlyModelViewSet:两个视图扩展类+ViewSetMixin+ GennericAPIView   	只读两个
ViewSetMixin: 魔方 重写了as_view 只要继承了他 以后写路由就变成了映射的形式
ViewSet: ViewSetMixin + APIView
GenericViewSet: ViewSetMixin+GenericAPIView
"""

# 重点
	-1.如果想改变路由写法【视图类中方法可任意命名】>>>ViewSet
    -2.如果在上述要求上 需要继承GenericAPIView>>>GenericViewSet 

5.视图层大总结

# 1.两个试图基类
	-APIView，GenericAPIView
# 2.5个试图扩展类，不是视图类，必须配合GenericAPIView

# 3.9 个视图子类，是视图类，只需要继承其中某一个即可

# 4.视图集 
	-ModelViewSet：路由写法变了，只需要写两行，5个接口都有了
    -ReadOnlyModelViewSet：路由写法变了，只需要写两行，2个只读接口都有了
    -ViewSetMixin：不是视图类，魔法，重写了as_view,路由写法变了，变成映射了
    	views.BookView.as_view({'get': 'list', 'post': 'create'})
    -ViewSet：ViewSetMixin+ APIView
	-GenericViewSet：ViewSetMixin+ GenericAPIView

    
    
# 举例子：发送短信接口，视图类叫SendView，方法叫send_sms，路由配置变了
	get--->send_sms
	class SendView(ViewSet):
        def send_sms(self,request):
            

路由系统

1.自动生成路由

# drf 由于继承ViewSetMin类 路由写法变了
	-原生+drf 以后的路由写法 可能会有如下情况(三种情况)
    	-path('books/',views.BookView.as_view()
    	-path('book/',views.BookView.as_view({'get':'list', 'post':'create'}))
     	-自动生成
              
# drf提供了两个路由类 继承ModelViewSet后 路由可以自动生成
              
# 使用步骤:
	-第一步:导入路由类
 	-第二步:实例得到对象(两个类 一般使用SimpleRouter)
	-第三步:注册 router.register('books',views.BookView, 'books')
	-第四步:在urlpatterns中注册 两种方式
    	-urlpatterns += router.urls
    	-include: path('/api/v1/',include(router.urls))  常用
              
"""
底层实现：本质是自动做映射 能够自动生成的前提是，视图类中要有五个方法中的某几个或多个
        get--->list
        get--->retrieve
        put--->update
        post--->create
        delete--->destory
	-ModelViewSet, ReadOnlyModelViewSet 可以自动生成
	
	-九个视图子类+配合ViewSetMixin  才可以自动生成
	-GenericAPIView+5个视图扩展类+配合ViewSetMixin 才能自动生成
"""

2.action装饰器

# action 写在视图类的方法上，可以自动生成路由

# 使用步骤
	- 1 写在视图类方法上
    class SendView(ViewSet):
        # methods指定请求方法，可以传多个
        # detail：只能传True和False
        	-False,不带id的路径：send/send_sms/
            -True，带id的路径：send/2/send_sms/
        #url_path：生成send后路径的名字，默认以方法名命名 
        # url_name：别名，反向解析使用，了解即可
        @action(methods=['POST'], detail=False)
        def send_sms(self, request):
            
            
 # 以后看到的drf路由写法
	后期，都是自动生成，一般不在urlpatterns 加入路由了
    
    
    
    
    
    
 # 补充：
	-1 不同请求方式可以使用不同序列化类
    -2 不同action使用不同序列化类
class SendView(GenericViewSet):
    queryset = None
    serializer_class = '序列化类'

    def get_serializer(self, *args, **kwargs):
        if self.action=='lqz':
            return '某个序列化类'
        else:
            return '另一个序列化列'
    @action(methods=['GET'], detail=True)
    def send_sms(self, request,pk):
        print(pk)
        # 手机号，从哪去，假设get请求，携带了参数
        phone = request.query_params.get('phone')
        print('发送成功,%s' % phone)
        return Response({'code': 100, 'msg': '发送成功'})

    @action(methods=['GET'], detail=True)
    def lqz(self,request):  # get
        # 序列化类
        pass

    @action(methods=['GET'], detail=True)
    def login(self,request):  # get
        # 序列化类
        pass

认证组件

# 访问某个接口，需要登陆后才能访问

# 第一步：写个登录功能，用户表
	-User表
    -UserToken表：存储用户登录状态 [这个表可以没有，如果没有，把字段直接写在User表上也可以]

1.登入接口

#### 表模型

class User(models.Model):
    username = models.CharField(max_length=32)
    password = models.CharField(max_length=32)



class UserToken(models.Model):  # 跟User是一对一
    token = models.CharField(max_length=32)
    user = models.OneToOneField(to='User', on_delete=models.CASCADE, null=True)
    # user :反向，表名小写，所有有user字段

### 路由
router.register('user', views.UserView, 'user')  # /api/v1/user/login     post 请求

# 视图类
####  登录接口  自动生成路由+由于登录功能，不用序列化，继承ViewSet
from .models import User, UserToken
import uuid


class UserView(ViewSet):
    @action(methods=['POST'], detail=False)
    def login(self, request):
        username = request.data.get('username')
        password = request.data.get('password')
        user = User.objects.filter(username=username, password=password).first()
        if user:
            # 用户存在，登录成功
            # 生成一个随机字符串--uuid
            token = str(uuid.uuid4())  # 生成一个永不重复的随机字符串
            # 在userToken表中存储一下：1 从来没有登录过，插入一条，     2 登录过，修改记录
            # 如果有就修改，如果没有就新增  (if 自己写)
            # kwargs 传入的东西查找，能找到，使用defaults的更新，否则新增一条
            UserToken.objects.update_or_create(user=user, defaults={'token': token})
            return Response({'code': '100', 'msg': '登录成功', 'token': token})
        else:
            return Response({'code': '101', 'msg': '用户名或密码错误'})