drf之请求、drf之响应、两个视图基类、5个视图扩展类(不是视图类）、原生django，怎么写向响应头写入数据

1 drf之请求
1.1 drf 之请求Request类
1.2 控制前端请求的编码格式

2 drf之响应
2.1 drf之Response对象源码
2.2 drf之响应格式

3 两个视图基类
3.1 基于 APIView写接口
3.2 基于GenericAPIView(只要跟数据库打交道)

4 五个视图扩展类(不是视图类–》先继承GenericAPIView)
5 原生django，怎么向响应头写入数据？

1 drf之请求

1.1 drf 之请求Request类

# 新的request对象---》之前聊过一部分

# from rest_framework.request import Request


# 1 以后视图类的方法中的request都是这个类的对象
# 2 以后使用request.data  取请求体中的数据
# 3 以后使用request.query_params  取请参数中的数据
# 4 以后其他属性，用起来跟之前一样---》重要
	-request.method 的时候---》实际上 request._request.'method'---》反射出来的
    -这个类from rest_framework.request import Request没有method，他会触发这个类的__getattr__---》
    
# 5 FILES 用起来跟之前一样，前端传入的文件在里面

## 了解：
	request._request
    视图类的方法中：  self 是咱们写的视图类的对象，self.request 是新的request
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

1.2 控制前端请求的编码格式

前端传入的编码:urlencoded,josn,form-data

# 某些接口只能接收某种编码的处理方式

#### 方式一：局部使用---》视图类上配置---》优先用它
class BookView(APIView):  # 视图类内的所有方法，只能接收json格式
    parser_classes = [JSONParser]
    
    
### 方式二：全局都生效---》所有接口都支持某一种或某几种
	REST_FRAMEWORK = {
    'DEFAULT_PARSER_CLASSES': [
        'rest_framework.parsers.JSONParser',
        'rest_framework.parsers.FormParser',
        # 'rest_framework.parsers.MultiPartParser'
    ]
}

#### 补充， 方式二：编码格式全局使用,以及浏览器和postman的相应编码格式
REST_FRAMEWORK = {
    'DEFAULT_PARSER_CLASSES': [
        'rest_framework.parsers.JSONParser',
        'rest_framework.parsers.FormParser',
        'rest_framework.parsers.MultiPartParser'
    ],
    'DEFAULT_RENDERER_CLASSES': [
        'rest_framework.renderers.JSONRenderer',
        'rest_framework.renderers.BrowsableAPIRenderer',
    ],
}


    
    
### 全局使用后，局部再限制---》只需要在视图类上加即可
class BookView(APIView):  # 全局如果用了，局部这样配，优先用局部的，也就是这个类管理的接口，只能接收form-data格式
    parser_classes = [MultiPartParser]

    
    
#### 为什么我们没有配置，三种也支持
	-drf自己有默认配置---》默认配置就是支持三种
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

代码解读

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.parsers import JSONParser, FormParser, MultiPartParser
from rest_framework.renderers import JSONRenderer, BrowsableAPIRenderer

# JSONParser： 解析json格式
# FormParser：解析urlencoded格式
# MultiPartParser：解析form-data格式


class BookView(APIView):
    '''
    # 方式二：编码格式全局使用,以及浏览器和postman的响应编码格式
    REST_FRAMEWORK = {
        # 全局配置编码格式
        'DEFAULT_PARSER_CLASSES': [
            'rest_framework.parsers.JSONParser',
            'rest_framework.parsers.FormParser',
            'rest_framework.parsers.MultiPartParser'
        ],
        # 全局配置响应编码格式
        'DEFAULT_RENDERER_CLASSES': [
            'rest_framework.renderers.JSONRenderer',
            'rest_framework.renderers.BrowsableAPIRenderer',
        ],
    }
    '''
    # 类属性 -----> parser是解析的意思

    # 方式一：局部使用：视图类上配置编码格式，优先用局部的
    # 如果以后这个视图类的所有方法，只能接收json格式的数据，别的接收不了，
    # 只需要在 parser_classes 中传入 JSONParser
    # parser_classes = [JSONParser]

    # 如果在setting.py中配置了全局，这里没有使用局部配置，就用全局的
    # 或者在布局重新配置
    parser_classes = [JSONParser, FormParser, MultiPartParser]

    # 响应编码格式
    renderer_classes = [JSONRenderer, BrowsableAPIRenderer]

    def get(self, request):
        # self 就是BookView的对象
        print(self.request is request)  # True
        print(self.headers)  # {'Allow': 'GET, POST, HEAD, OPTIONS', 'Vary': 'Accept'}
        '''
        def __init__(self, data=None, status=None, template_name=None, headers=None,
                 exception=False, content_type=None):
        data=None             # 字符串，列表，字典------> 放在了响应体中------>它是__init__()的第一个参数
        status=None           # 这是http响应状态码，默认是200，不能使用status=100，这表示请求正在处理
        template_name=None    # 模板名字默认是：rest_framework/api.html  可以定制自己返回的页面
        headers=None          # http响应头，后期我们往响应头中放数据
        exception=False     
        content_type=None     # 响应编码格式     
        '''
        res = Response(data={}, status=200, headers={'xxx': 'yyyy'})
        print(res.data)
        print(res.has_header('xxx'))  # True
        return res

    def post(self, request):
        # 请求体中带数据 ------> http请求有请求地址：请求头、请求体
        # 带在请求体中的数据，有编码格式：3种 ------> 无论是哪种，携带的数据都是从 request.data 中获取
        # 假设这个接口，只允许携带 json 格式，其他格式都报错，怎么做呢？
        # 需要配置类属性
        print(request.data)
        return Response('新增')


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

2 drf之响应

2.1 drf之Response对象源码

# from rest_framework.response import Response
### __init__ 中需要传这几个参数，不传也可以
data=None   # 字符串，列表，字典----》放在了响应 体 中 ---》第一个参数是它
status=None, # http响应状态码，默认是200，千万不能写成1xx
headers=None, # http响应头，后期我们可以往响应头中放数据


content_type=None # 响应编码格式(不用管，用浏览器访问就是：text/html，用postman就是：json格式)
template_name=None   # 模版名字  默认是：rest_framework/api.html  了解，可以定制自己返回的页面样子


### 原生django，向响应头写入数据



###补充：后面会用---》通过res.data 就能取到当时放的datga
res=Response(data={},status=500,headers={'xxx':'yyy'})
print(res.data)
return res


### 补充：取当时放的响应头
res.headers 拿不到数据，可以通过下面的方式或得到
print(res['xxx'])
print(res.has_header('zzz'))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

2.2 drf之响应格式

# 响应有编码格式：默认支持json和text/html(浏览器)

# 修改只支持json
### 局部使用
class BookView(APIView):
   	renderer_classes = [BrowsableAPIRenderer]
### 全局使用
REST_FRAMEWORK = {
    'DEFAULT_RENDERER_CLASSES': [
        'rest_framework.renderers.JSONRenderer',
        'rest_framework.renderers.BrowsableAPIRenderer',
    ],
}

##局部禁用---》全局已经配置了---》局部想用浏览器的样子
class BookView(APIView):
   	renderer_classes = [BrowsableAPIRenderer]
    
    
    
# 如果不配置---》有默认
	-解析：三种编码都能解析
    -响应：浏览器访问看到浏览器的样子，postman访问，看到json格式
    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

3 两个视图基类

# Book 的 5个接口  基于APIView编写
# Publish 的5个接口  基于GenericAPIView编写
1
2

3.1 基于 APIView写接口

class BookView(APIView):
    def get(self, request):
        book_list = Book.objects.all()
        ser = BookSerializer(instance=book_list, many=True)
        return Response(ser.data)

    def post(self, request):
        ser = BookSerializer(data=request.data)
        if ser.is_valid():
            ser.save()  # 反序列化保存
            return Response(ser.data)  # 创建成功后，返回创建后的对象， 做了个序列化
        else:
            return Response(ser.errors)


class BookDetailView(APIView):
    def get(self, request, pk):
        book = Book.objects.filter(pk=pk).first()
        ser = BookSerializer(instance=book)
        return Response(ser.data)

    def put(self, request, pk):
        book = Book.objects.filter(pk=pk).first()
        ser = BookSerializer(instance=book, data=request.data)
        if ser.is_valid():
            ser.save()
            return Response(ser.data)
        else:
            return Response(ser.errors)

    def delete(self, request, pk):
        Book.objects.filter(pk=pk).delete()
        return Response('')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

3.2 基于GenericAPIView(只要跟数据库打交道)

自己写GenericAPIView

class GenericAPIView(APIView):
    queryset = None
    serializer_class = None
	
    def get_queryset(self):
        return self.queryset.all()  # 真正使用的时候，再加all获取所有才行

    def get_serializer(self, *args, **kwargs):
        return self.serializer_class(*args, **kwargs)

    def get_object(self, pk):
        res = self.get_queryset()
        return res.filter(pk=pk).first()
1
2
3
4
5
6
7
8
9
10
11
12
13

GenericAPIView 有类属性和方法

    	### 重要属性### 
    	-queryset：以后放所有某个表查询出的数据
        -serializer_class：要序列化的类
        
        ### 重要方法###
        -get_queryset  :要序列化的所有数据，qs对象
        -get_serializer ：序列化类
        -get_object  ：修改，查询的单条
        
        ## 了解类属性：
        -lookup_field = 'pk'  路由使用转换器，转换出来的参数，查询单条要用到，如果改了，路由对应也要修改，一般不改
        -filter_backends：后面详细讲     过滤 功能
        -pagination_class ：后面详细讲  分页
        
        ### 了解方法
        -get_serializer_class  后期咱们可能会重写它，指定某些方法使用不同的序列化类
        -filter_queryset 后面跟过滤功能一起讲
        
        
        
 ###代码

class PublishView(GenericAPIView):
    queryset = Publish.objects.all()  # 类只要加载，就会执行，查了所有数据，不能以它为准
    serializer_class = PublishSerializer

    def get(self, request):
        obj_list = self.get_queryset()  # 以用的时候为准
        ser = self.get_serializer(instance=obj_list, many=True)
        return Response(ser.data)

    def post(self, request):
        ser = self.get_serializer(data=request.data)
        if ser.is_valid():
            ser.save()  # 反序列化保存
            return Response(ser.data)  # 创建成功后，返回创建后的对象， 做了个序列化
        else:
            return Response(ser.errors)


class PublishDetailView(GenericAPIView):
    serializer_class = PublishSerializer
    queryset = Publish.objects.all()

    def get(self, request, pk):
        obj = self.get_object()
        ser = self.get_serializer(instance=obj)
        return Response(ser.data)

    def put(self, request, pk):
        obj = self.get_object()
        ser = self.get_serializer(instance=obj, data=request.data)
        if ser.is_valid():
            ser.save()
            return Response(ser.data)
        else:
            return Response(ser.errors)

    def delete(self, request, pk):
        self.get_object().delete()
        return Response('')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

3.3 总结

# 错误1 ：一定要在用数据的时候再查
def get_queryset(self):
        return self.queryset.all() 
    
    
# 错误2：没有在类属性上配置 queryset--->源码中做了断言

1
2
3
4
5
6
7

4 五个视图扩展类(不是视图类–》先继承GenericAPIView)

from rest_framework.generics import GenericAPIView
from rest_framework.mixins import RetrieveModelMixin, ListModelMixin, CreateModelMixin, UpdateModelMixin, DestroyModelMixin

# RetrieveModelMixin,  查询一条，写了一个方法  retrieve---》代码就是 跟咱们之前写获取单条get方法内容一样
# CreateModelMixin  新增一条写了一个方法  create---》代码就是 跟咱们之前写新增一条 post  方法内容一样
# DestroyModelMixin,删除一条写了一个方法  destroy---》代码就是 跟咱们之前写删除一条 delete  方法内容一样
# ListModelMixin,查询所有写了一个方法  list---》代码就是 跟咱们之前写查询所有 get  方法内容一样
# UpdateModelMixin  修改一个写了一个方法  update---》代码就是 跟咱们之前写更新一条put  方法内容一样

# 为什么写5个，不写俩，因为后期不一定 5个接口都写

class PublishView(GenericAPIView, ListModelMixin, CreateModelMixin):
    queryset = Publish.objects.all()  # 类只要加载，就会执行，查了所有数据，不能以它为准
    serializer_class = PublishSerializer

    def get(self, request):
        return self.list(request)

    def post(self, request):
        # return  self.create(request) # 一定不要忘了return
        return super().create(request)  # 一定不要忘了return


class PublishDetailView(GenericAPIView, RetrieveModelMixin, UpdateModelMixin, DestroyModelMixin):
    serializer_class = PublishSerializer
    queryset = Publish.objects.all()

    def get(self, request, pk):
        return self.retrieve(request, pk)

    def put(self, request, pk):
        return self.update(request, pk)

    def delete(self, request, pk):
        return self.destroy(request, pk)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

5 原生django，怎么向响应头写入数据？

from django.http import HttpResponse

def custom_header_view(request):
    # 创建一个 HttpResponse 对象
    response = HttpResponse("hello")

    # 向响应头添加自定义的 HTTP 头信息
    response['X-Custom-Header'] = 'Hello, World!'

    # 返回 HttpResponse 对象
    return response

总结：首先创建了一个 HttpResponse 对象，并设置了响应的内容。然后，
通过 response['Header-Name'] 的方式向响应头添加自定义的响应头信息。
在这里，我们添加了一个名为 "X-Custom-Header" 的自定义头，其值为 "Hello, World!"。
最后，将 HttpResponse 对象返回，以便将其发送给客户端。
这样，客户端将会接收到包含自定义响应头信息的响应。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18