Django之ModelForm操作

一、ModelForm的使用

　　顾名思义，ModelForm就是将Model与Form进行绑定，Form有自动生成表单的作用，但是每一个forms字段需要自己手动填写，而Model就是数据库表包含了所有的数据字段。所以ModelForm有着以下功能：

Form所有的功能
将Model字段自动转换成forms字段

（一）实例演示

1、创建ModelForm

from app01 import models

from django.forms import ModelForm

from django.forms.widgets import Textarea

class BookModelForm(ModelForm):

    class Meta:

        model = models.Book  #对应的Model类

        fields = '__all__'  #对应的Model类中字段

        exclude = None      #排除的字段

        labels = {

            "title":"书籍名",       #用于html页面中显示的名字

            "price":"价格"

        }

        help_texts = {

            "title":"我是书籍的帮助信息" #自定义帮助信息

        }

        error_messages = {

            "title":{"required":"书籍名不能为空"}  #自定义错误信息

        }

        widgets = {

            "title":Textarea(attrs={"class":"form-control"}) #自定义属性

        }

2、添加数据

from django.shortcuts import render,redirect,HttpResponse

def BookAdd(request):

    book_list = models.Book.objects.all()

    #获取添加数据的表单

    if request.method == "GET":

        form = BookModelForm()

        return render(request,'booklist.html',locals())

    #POST请求添加数据

    form = BookModelForm(data=request.POST)

    if form.is_valid():

        #保存数据

        form.save()

        return HttpResponse('...')

3、修改数据

def BookEdit(request,id):

    book = models.Book.objects.filter(id=id).first()

    #获取修改数据的表单

    if request.method == "GET":

        form = BookModelForm(instance=book)

        return render(request, 'booklist.html', locals())

    #POST请求添加修改过后的数据

    form = BookModelForm(data=request.POST,instance=book)

    #对数据验证并且保存

    if form.is_valid():

        form.save()

    return HttpResponse('...')

4、路由配置

urlpatterns = [

    re_path('books/$', tests.BookAdd),

    re_path('books/(?P<id>\d+)/$', tests.BookEdit),

]

5、前端html渲染

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>Title</title>

</head>

<body>

<form method="POST" novalidate>

        {% csrf_token %}

        {% for book in form %}

            <div>

                {# 拿到数据字段的labels,没有就默认显示字段名 #}

                <label >{{ book.label }}</label>

                <div>{{ book }}{{ book.help_text }}</div>

            </div>

        {% endfor %}

        <div class="col-md-2 col-md-offset-10">

            <input type="submit" value="提交" class="btn-primary">

        </div>

    </form>

</body>

</html>

（二）实例解析

1、model字段转成forms字段

在创建ModelForm类时会将model字段转成forms字段，这里着重说明三种情况：

model字段是ForeignKey

如果model中是外键，那么在forms字段中对应的就是ModelChoiceField，如果使用的是Form，那么外键就应该这样定义：

publish=forms.ModelChoiceField(queryset=Publish.objects.all())

当然，在ModelForm中已经帮你自动实现了，将会产生这样的标签：

<select id="id_publish" name="publish">

<option value="obj1.pk">Object1</option>

<option value="obj2.pk">Object2</option>

...

</select>

model字段是ManyToMany

如果model中是ManyToMany，那么在forms字段中对应的就是ModelMultipleChoiceField，如果使用的是Form，那么ManyToMany就应该这样定义：

authors=forms.ModelMultipleChoiceField(queryset=Author.objects.all())

当然，在ModelForm中已经帮你自动实现了，将会产生这样的标签：

<select name="authors" id="id_authors" multiple="multiple" required="">

  <option value="obj1.pk">obj1</option>

  <option value="obj2.pk">obj2</option>

...

</select>

model字段中有choice参数

在model中可能会遇到这样的情况：

    status_choices=(

        (1,'已签合同'),

        (2,'未签合同')

    )

    status=models.IntegerField(choices=status_choices,verbose_name='状态',default=2)

这样的情况在forms中对应的字段是ChoiceField字段，如果使用Form自定义字段，可以这样写：

status=forms.ChoiceField(choices=((1,"已签合同"),(2,"未签合同")))

当然，在ModelForm中也已经帮你自动实现了。

总结

在查看ChoiceField、ModelChoiceField、ModelMultipleChoiceField源码可知它们三者关系：

    ChoiceField(Field)

    ModelChoiceField(ChoiceField)

    ModelMultipleChoiceField(ModelChoiceField)

它们分别依次继承，所以最后一个有它们所有的属性和方法。

2、保存数据时使用save方法

添加数据

这比Form更为简单和直接，在forms中要么通过cleaned_data将数据依次取出分别保存，要么以字典的形式一次存入：

...

obj = BookForm(request.POST)

if obj.is_valid():

　　　　　　models.Book.objects.create(**obj.cleaned_data)

...

但是在ModelForm中，可以这样使用：

...

obj = BookModelForm(request.POST)

if obj.is_valid():

　　　　　　obj.save()

...

修改数据

在修改数据时Form和ModelForm也是略有不同的在Form中：

...

obj = BookForm(request.POST)

　　　　if obj.is_valid():

　　　　　　models.Book.objects.filter(id=nid).update(**obj.cleaned_data)

...

而在ModelForm中需要传入实例：

...

obj = BookModelForm(data=request.POST,instance=book)

    if form.is_valid():

        form.save()

...

三、源码一览

假设这里以修改视图流程来了解一下源码：

（一）ModelForm实例化

form = BookModelForm(instance=book)

　　ModelForm实例化并且传入instance参数，它会先使用元类生成自己，如果有__new__先执行__new__方法并且返回生成的对象，然后执行__init__方法初始化参数。在元类当中可以看到最后返回了当前BookModelForm，并且将收集了所有的已经声明的字段赋值给该类：

class ModelFormMetaclass(DeclarativeFieldsMetaclass):

    def __new__(mcs, name, bases, attrs):

...

...

        new_class.base_fields = fields

...

...

        return new_class

然后再执行BaseModelForm中的__init__方法进行初始化：

class BaseModelForm(BaseForm):    
　　　def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None,

                 initial=None, error_class=ErrorList, label_suffix=None,

                 empty_permitted=False, instance=None, use_required_attribute=None):
...
...

            object_data = {}
...

            self.instance = instance
...
...

#获取self.fields = copy.deepcopy(self.base_fields)

        super().__init__(

            data, files, auto_id, prefix, object_data, error_class,

            label_suffix, empty_permitted, use_required_attribute=use_required_attribute,

        )

...

初始化过程中将instance接收进来，并且将self.base_fields进行深拷贝给self.fields。

（二）is_valid

这个对ModelForm进行校验就是和Form的一样：

    def is_valid(self):

        """Return True if the form has no errors, or False otherwise."""

        return self.is_bound and not self.errors

在self.errors方法中执行的self.full_clean方法：

    def full_clean(self):

        """

        Clean all of self.data and populate self._errors and self.cleaned_data.

        """

        self._errors = ErrorDict()

        if not self.is_bound:  # Stop further processing.

            return

        self.cleaned_data = {}

        # If the form is permitted to be empty, and none of the form data has

        # changed from the initial data, short circuit any validation.

        if self.empty_permitted and not self.has_changed():

            return

        self._clean_fields()#对每一个字段进行执行clean_fieldname方法

        self._clean_form() #返回cleaned_data

        self._post_clean() #预留钩子

这也就注定了Form中存在的功能ModelForm都有，无论是字段的验证还是其它的功能。

（三）save

save方法应该说比Form操作更方便快捷，可以简单的看看内部源码：

    def save(self, commit=True):

        """

        Save this form's self.instance object if commit=True. Otherwise, add

        a save_m2m() method to the form which can be called after the instance

        is saved manually at a later time. Return the model instance.

        """

        if self.errors:

            raise ValueError(

                "The %s could not be %s because the data didn't validate." % (

                    self.instance._meta.object_name,

                    'created' if self.instance._state.adding else 'changed',

                )

            )

        if commit:

            # If committing, save the instance and the m2m data immediately.

            self.instance.save()

            self._save_m2m()

        else:

            # If not committing, add a method to the form to allow deferred

            # saving of m2m data.

            self.save_m2m = self._save_m2m

        return self.instance

save方法有一个默认参数commit=True，表示保存实例以及ManyToMany数据，self.instance.save()，调用的是model实例的save方法（位于django.db.models.Model）：

 def save(self, force_insert=False, force_update=False, using=None,

             update_fields=None):

        """

        Save the current instance. Override this in a subclass if you want to

        control the saving process.

        The 'force_insert' and 'force_update' parameters can be used to insist

        that the "save" must be an SQL insert or update (or equivalent for

        non-SQL backends), respectively. Normally, they should not be set.

        """

        # Ensure that a model instance without a PK hasn't been assigned to

        # a ForeignKey or OneToOneField on this model. If the field is

        # nullable, allowing the save() would result in silent data loss.

        for field in self._meta.concrete_fields:

            # If the related field isn't cached, then an instance hasn't

            # been assigned and there's no need to worry about this check.

            if field.is_relation and field.is_cached(self):

                obj = getattr(self, field.name, None)

                # A pk may have been assigned manually to a model instance not

                # saved to the database (or auto-generated in a case like

                # UUIDField), but we allow the save to proceed and rely on the

                # database to raise an IntegrityError if applicable. If

                # constraints aren't supported by the database, there's the

                # unavoidable risk of data corruption.

                if obj and obj.pk is None:

                    # Remove the object from a related instance cache.

                    if not field.remote_field.multiple:

                        field.remote_field.delete_cached_value(obj)

                    raise ValueError(

                        "save() prohibited to prevent data loss due to "

                        "unsaved related object '%s'." % field.name

                    )

        using = using or router.db_for_write(self.__class__, instance=self)

        if force_insert and (force_update or update_fields):

            raise ValueError("Cannot force both insert and updating in model saving.")

        deferred_fields = self.get_deferred_fields()

        if update_fields is not None:

            # If update_fields is empty, skip the save. We do also check for

            # no-op saves later on for inheritance cases. This bailout is

            # still needed for skipping signal sending.

            if len(update_fields) == 0:

                return

            update_fields = frozenset(update_fields)

            field_names = set()

            for field in self._meta.fields:

                if not field.primary_key:

                    field_names.add(field.name)

                    if field.name != field.attname:

                        field_names.add(field.attname)

            non_model_fields = update_fields.difference(field_names)

            if non_model_fields:

                raise ValueError("The following fields do not exist in this "

                                 "model or are m2m fields: %s"

                                 % ', '.join(non_model_fields))

        # If saving to the same database, and this model is deferred, then

        # automatically do a "update_fields" save on the loaded fields.

        elif not force_insert and deferred_fields and using == self._state.db:

            field_names = set()

            for field in self._meta.concrete_fields:

                if not field.primary_key and not hasattr(field, 'through'):

                    field_names.add(field.attname)

            loaded_fields = field_names.difference(deferred_fields)

            if loaded_fields:

                update_fields = frozenset(loaded_fields)

        self.save_base(using=using, force_insert=force_insert,

                       force_update=force_update, update_fields=update_fields)

save

如果commit=False，就不会保存实例，当调用save方法后不会保存ManyToMany字段，需要自行去调用save_m2m方法，例如：

# Create a form instance with POST data.

>>> f = BookForm(request.POST)

# Create, but don't save the new book instance.

>>> new_book = f.save(commit=False)

# Modify the book in some way.

>>> new_book.some_field = 'some_value'

# Save the new instance.

>>> new_book.save()

# Now, save the many-to-many data for the form.

>>> f.save_m2m()

参考文章：https://docs.djangoproject.com/en/2.2/topics/forms/modelforms/#modelform

四、扩展

（一）自定义BaseModelForm

class BaseRequestModelForm(object):

    def __init__(self, request, *args, **kwargs):

        self.request = request

        super(BaseRequestModelForm, self).__init__(*args, **kwargs)

　　这样，ModelForm中可以传入request参数，当然还可以添加其它参数，然后再继承自己的ModelForm，这样自定义的ModelForm不仅仅有自己的功能，还可以传参定制其它功能，在使用时继承下面这个ModelForm即可：

class BaseModelForm(BaseRequestModelForm,forms.ModelForm):

    def __init__(self,request,*args,**kwargs):

        super().__init__(request,*args,**kwargs)

        #####给modelform字段加样式

        for name,field in self.fields.items():

            attrs_dict={'class':'form-control'}

            if 'DateTimeField' in field.__repr__():

                attrs_dict = {'class': 'form-control', 'date_time': 'datetimepicker', 'size': ''}

            field.widget.attrs.update(attrs_dict)

（二）动态生成ModelForm

　　每一个model都可以对应一个ModelForm类可用于自动生成表单等功能，但是如果能够动态生成ModelForm岂不是更加省事，其实就是动态的生成一个类，并且设置类的一些属性，首先先看一个普通的ModelForm类，依照此类动态生成：

class BookModelForm(ModelForm):

    class Meta:

        model = models.Book  #对应的Model类

        fields = '__all__'  #对应的Model类中字段

    def __new__(cls,*args,**kwargs):

        """

        :param cls:

        :param args:

        :param kwargs:

        :return:

        """

        #base_fields = [{'field_name':field_obj},] forms字段对象

        for field_name in cls.base_fields:

             field_obj = cls.base_fields[field_name]

             field_obj.widget.attrs.update({'class':'form-control'})

        return ModelForm.__new__(cls)

然后就可以进行动态生成这样的ModelForm类了。

from django.forms import ModelForm

def CreateDynamicModelForm(model,fields=None,form_create=False,*args,**kwargs):

    #默认为修改表单

    attrs = {} #创建类使用的属性字典

    #如果没有传入fields默认就是全部

    if not fields:

        fields = "__all__"

    #传入request参数

    if kwargs.get('request'):

        attrs["request"] = kwargs.get('request')

    class Meta:

        pass

    setattr(Meta,'model',model)

    setattr(Meta,'fields',fields)

    attrs["Meta"] = Meta

    #如果给每一个字段加入样式，重写__new__方法

    def __new__(cls,*args,**kwargs):

        """

        :param cls:

        :param args:

        :param kwargs:

        :return:

        """

        #base_fields = [{'field_name':field_obj},] forms字段对象

        for field_name in cls.base_fields:

             field_obj = cls.base_fields[field_name]

             field_obj.widget.attrs.update({'class':'form-control'})

        return ModelForm.__new__(cls)

    attrs["__new__"] = __new__

    ##创建类

    name = 'DynamicModelForm' #创建类的名称

    bases = (ModelForm,) #创建类的基类

    dynamic_model_form = type(name,bases,attrs)

    return dynamic_model_form

以后就可以这样使用了，也不用那么麻烦的手动写ModelForm类了。

from django.shortcuts import render,redirect,HttpResponse

from app01 import models

#添加数据

def BookAdd(request):

    book_list = models.Book.objects.all()

    BookModelForm = CreateDynamicModelForm(models.Book, form_create=True, request=request)

    #获取添加数据的表单

    if request.method == "GET":

        form = BookModelForm()

        return render(request,'booklist.html',locals())

    #POST请求添加数据

    form = BookModelForm(data=request.POST)

    if form.is_valid():

        #保存数据

        form.save()

        return HttpResponse('...')

#修改数据

def BookEdit(request,id):

   #动态生成ModelForm类

    BookModelForm = CreateDynamicModelForm(models.Book,request=request)

    book = models.Book.objects.filter(id=id).first()

    #获取修改数据的表单

    if request.method == "GET":

        form = BookModelForm(instance=book)

        return render(request, 'booklist.html', locals())

    #POST请求添加修改过后的数据

    form = BookModelForm(data=request.POST,instance=book)

    #对数据验证并且保存

    if form.is_valid():

        form.save()

    return HttpResponse('...')