APIView 怎么写？

前后端分离项目配置流程

1.创建项目和子应用。

2.配置项目：

INSTALLED_APPS = [
        'django.contrib.admin',
        'django.contrib.auth',
        'django.contrib.contenttypes',
        'django.contrib.sessions',
        'django.contrib.messages',
        'django.contrib.staticfiles',
    
        'game',  # 注册子应用
        'rest_framework',  # drf框架
        'corsheaders',  # 跨域
    ]
    
    MIDDLEWARE = [
        'django.middleware.security.SecurityMiddleware',
        'django.contrib.sessions.middleware.SessionMiddleware',
        'django.middleware.common.CommonMiddleware',
        # 'django.middleware.csrf.CsrfViewMiddleware',
        'django.contrib.auth.middleware.AuthenticationMiddleware',
        'django.contrib.messages.middleware.MessageMiddleware',
        'django.middleware.clickjacking.XFrameOptionsMiddleware',
        'corsheaders.middleware.CorsMiddleware',  # 跨域中间件
    ]
    
    CORS_ORIGIN_ALLOW_ALL = True # 允许所有源访问
    
    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.mysql',
            'HOST': 'localhost',
            'PORT': 3306,
            'USER': 'root',
            'PASSWORD': 'root',
            'NAME': 'test',
        }
    }
    
    LANGUAGE_CODE = 'zh-Hans'
    
    TIME_ZONE = 'Asia/Shanghai';

3.安装数据库

4.编写模型类

5.迁移、注册表、创建超级用户、添加测试数据

6.路由分发

7.序列化器*

序列化：ORM操作的数据 -> JSON数据 查询

反序列化：JSON数据 -> ORM操作的数据 添加和修改

序列化器：用于实现序列化和反序列化的工具。

 # 在子应用下新建serializers.py文件
    from rest_framework import serializers  # 导入
    from game.models import Game
    
    # 定义一个普通序列化器，用于处理Game模型类相关的数据
    class GameSerializer(serializers.Serializer):
        # 映射字段
        id = serializers.IntegerField()  # 添加id字段
        name = serializers.CharField(max_length=20)
        kind = serializers.CharField(max_length=20)
        score = serializers.IntegerField()
        age = serializers.IntegerField()
    
        # 实现增加功能时需要实现create方法
        # validated_data时要添加的数据
        # ** 拆包
        def create(self, validated_data):
            result = Game.objects.create(**validated_data)
            return result  # 返回结果
    
        # 实现更新功能需要实现update方法
        # instance要更新的orm对象
        # validated_data去更新这个对象的数据
        def update(self, instance, validated_data):
            instance.id = validated_data.get('id')
            instance.name = validated_data.get('name')
            instance.kind = validated_data.get('kind')
            instance.score = validated_data.get('score')
            instance.age = validated_data.get('age')
            instance.save()  # 保存更新的数据
            # 修改数据2中方法 1.update 2.save
            return instance
    
    #######################################################################
    
    # 模型序列化器
    class GameSerializer2(serializers.ModelSerializer):
        class Meta:  # 配置元类
            model = Game   # 指定模型类
            fields = "__all__"  # 指定字段

8.编写视图*

使用序列化器实现增删改查操作。(查询所有数据、查询单个数据、增加一个数据、修改数据、删除一个数据)

动态路由：删除delete、修改put、查询单个数据get

静态路由：查询所有数据get、增加post

通过分析，使用2个类视图实现增删查改功能。

 # 使用序列化器会用到的参数：instance 实例ORM操作数据   data JSON数据
    # def func(instance, data)
    # 调用函数 位置参数: func(instance=a,data=b) -> func(a,b)  func(instance=a)-> func(a)
    # 调用函数 指定参数: func(data=a, instance=b)  func(data=a)  
    
    from django.shortcuts import render
    from rest_framework.views import APIView
    from rest_framework.response import Response
    from game.models import Game
    from game.serializer import GameSerializer
    
    # Create your views here.
    # 实现游戏角色的查询全部 和 添加
    class GameView1(APIView):
        def get(self, request):  # 1
            # ORM操作数据 -》 json数据  序列化
            # 获取全部游戏信息 ORM操作数据
            games_data = Game.objects.all()
            # 使用序列化器，实现序列化
            # 多个数据需要加上 many=True
            ser = GameSerializer(games_data, many=True)
            # 注意返回的时ser.data 而不是ser
            return Response(ser.data)
    
    
        def post(self, request):  # 2 增加数据
            # request.data 就是前端提交的json数据
            # 1.使用序列化器进行反序列化，data参数就是要反序列化的数据
            ser = GameSerializer(data=request.data)
            # 2.校验  参数raise_exception=True,出现异常时自动抛出异常
            if ser.is_valid(raise_exception=True):
                # 3.保存
                ser.save()
                return Response({'msg':'添加数据成功'}, status=201)
            return Response({'msg': '添加数据失败'}, status=500)
    
    
    
    # 根据id 实现 单个 查询 修改 删除
    class GameView2(APIView):
        def get(self, request, id):  # 3
            # 根据id获取数据，单个数据
            try:
                game_data = Game.objects.get(id=id)
            except Exception as e:
                print(e)
                return Response({'msg':'数据不存在'}, status=404)
            ser = GameSerializer(game_data)
            return Response(ser.data, status=200)
    
        def put(self, request, id):  # 4 反序列化之更新
            # 1.获取要更新的数据 ORM操作的数据->instance
            try:
                game_data = Game.objects.get(id=id)
            except Exception as e:
                print(e)
                return Response({'msg':'数据不存在'}, status=404)
            # 2.反序列化 game_data要更新的orm对象 request.data去更新这个对象的数据
            ser = GameSerializer(instance=game_data, data=request.data)
            # 3.校验
            if ser.is_valid(raise_exception=True):
                # 4.保存
                ser.save()
                return Response({'msg':'更新数据成功'}, status=201)
            return Response({'msg':'更新数据失败'}, status=500)
    
        def delete(self, request, id):  # 5 删除
            try:
                Game.objects.filter(id=id).delete()
            except Exception as e:
                print(e)
                return Response({'msg': '删除失败'}, status=404)
            return Response({'msg': '删除数据成功'}, status=204)

总结：

1.序列化时，将模型类对象(ORM操作的数据)传入instance参数，返回结果时使用的是ser.data属性获取得到。

2.反序列创建时，将前端提交的数据(JSON数据)传给data参数，要使用is_valid进行校验，调用save进行保存。

3.反序列化更新是，将要更新的数据对象(ORM操作数据)传入instance参数，更新后的数据((JSON数据))传入data参数

4.数据多个时，记得加many=True。