Django多对多CURD

Django 框架操作数据库 用到的是 ORM 思想。
什么是 ORM 呢？
Object Relational Mapping 对象关系映射，就是 操作数据库的 语句 和 Python 乃至 Django 的不太一样 为了 方便，面向数据库的关系更改成了 面向对象。详细点的就是，创建 实例 代替 数据库中的表，类属性就是 对应的 字段了。

• models

# =====models.py=====
from django.db import models


class UserModel(models.Model):
    user_name = models.CharField(max_length=20)
    gender = models.CharField(max_length=5)
    age = models.IntegerField()

    class Meta:
        db_table = "user_model"
        verbose_name = "用户表"
        verbose_name_plural = verbose_name


class ClassRoomModel(models.Model):
    class_name = models.CharField(max_length=30)
    address = models.CharField(max_length=30)

    class Meta:
        db_table = "class_room_model"
        verbose_name = "班级表"
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.class_name


class RoleModel(models.Model):
    role_name = models.CharField(max_length=30)  # 角色名称
    age = models.IntegerField()                  # 角色年龄
    height = models.IntegerField()               # 角色身高
    # 所属班级外键字段
    class_room = models.ForeignKey(ClassRoomModel, on_delete=models.CASCADE, null=True)
    # 多对多用户字段
    users = models.ManyToManyField(UserModel, related_name="role_users", null=True)

    class Meta:
        db_table = "role_model"
        verbose_name = "角色表"
        verbose_name_plural = verbose_name

• serializers

# ----------serializers.py----------
from rest_framework import serializers
from apps.demoapp.models import *


# 用户表ModelSerializer序列化器
class UserSer(serializers.ModelSerializer):
    class Meta:
        model = UserModel
        fields = "__all__"


# 角色表ModelSerializer序列化器
class RoleNewSer(serializers.ModelSerializer):
    class Meta:
        model = RoleModel
        fields = "__all__"


# 角色表序列化器
class RoleSer(serializers.Serializer):
    role_name = serializers.CharField(max_length=20)
    age = serializers.IntegerField()
    height = serializers.IntegerField()
    class_room = serializers.StringRelatedField(read_only=True)

    def create(self, validated_data):
        return RoleModel.objects.create(**validated_data)


# 班级表序列化器
class ClassRoomSer(serializers.Serializer):
    class_name = serializers.CharField(max_length=30)
    address = serializers.CharField(max_length=30)

    def create(self, validated_data):
        return ClassRoomModel.objects.create(**validated_data)

    def update(self, instance, validated_data):
        instance.class_name = validated_data.get("class_name", instance.class_name)
        instance.address = validated_data.get("address", instance.address)
        instance.save()
        return instance


# 角色表多对多序列化器
class RoleManySer(serializers.Serializer):
    role_name = serializers.CharField(max_length=20)
    age = serializers.IntegerField()
    height = serializers.IntegerField()
    id = serializers.IntegerField(read_only=True)
    class_room = serializers.IntegerField(write_only=True)
    users = serializers.ListField(write_only=True)

    def create(self, validated_data):
        # 获取外键值
        id = validated_data.pop("class_room")
        # 获取对应关系
        list = validated_data.pop("users")
        # 创建角色信息
        role_obj = RoleModel.objects.create(class_room_id=id, **validated_data)
        # 查询对应关系的具体对象
        user_obj = UserModel.objects.filter(id__in=list)
        # 两个关系绑定
        role_obj.users.add(*user_obj)
        return role_obj

• 多对多表CURD（增删改查）

# ----------views.py----------
from rest_framework.response import Response
from django.http.response import HttpResponse, JsonResponse
from rest_framework.views import APIView, View
from apps.demoapp.serializers import *

class ManyView(APIView):
    def get(self, request):
        # 获取前端传递的用户id
        uid = request.data.get("uid")
        # 根据用户id查询用户信息
        user_obj = UserModel.objects.get(id=uid)
        # 拿出该用户关联的角色信息
        role_obj = user_obj.role_users.all()
        # 序列化数据
        ser = RoleNewSer(role_obj, many=True)
        # 返回数据
        return Response(ser.data)

    def post(self, request):
        # 单条添加
        # 获取前端传递的用户id
        uid = request.data.get("uid")
        # 获取前端传递的角色id
        rid = request.data.get("rid")
        # # 验证是否2条数据都接受到了
        if not all([uid, rid]):
            return Response({"msg": "缺少参数", "code": 400})
        # # 查询出用户id对应的用户信息
        user_obj = UserModel.objects.get(id=uid)
        # # 查询出角色id对应的角色信息
        role_obj = RoleModel.objects.get(id=rid)
        # # 为该用户添加上对应的角色
        user_obj.role_users.add(role_obj)
        # # 为该角色添加上绑定的用户
        # role_obj.users.add(user_obj)
        return Response({"msg": "绑定成功", "code": 200})

        # 批量添加
        # 查询出用户id对应的用户信息
        # user_obj = UserModel.objects.get(id=uid)
        # 查询出角色id对应的角色信息
        # role_obj = RoleModel.objects.filter(id__gt=rid)
        # 为该用户添加上对应的角色
        # user_obj.role_users.add(*role_obj)
        # return Response({"msg": "绑定成功", "code": 200})

    def put(self, request):
        # 获取前端传递的用户id
        uid = request.data.get("uid")
        # 获取前端传递的角色id
        rid = request.data.get("rid")
        # 查询出用户id对应的用户信息
        user_obj = UserModel.objects.filter(id=uid)
        # 查询出角色id对应的角色信息
        role_obj = RoleModel.objects.get(id=rid)
        # 更改该用户的角色id
        role_obj.users.set(user_obj)
        return Response({"msg": "绑定更改成功", "code": 200})

    def delete(self, request):
        # 获取前端传递的用户id
        uid = request.data.get("uid")
        # 获取前端传递的角色id
        rid = request.data.get("rid")
        # 查询出用户id对应的用户信息
        user_obj = UserModel.objects.get(id=uid)
        # 查询出角色id对应的角色信息
        role_obj = RoleModel.objects.get(id=rid)
        # 更改该用户的角色id
        role_obj.users.remove(user_obj)
        return Response({"msg": "绑定删除成功", "code": 200})