千与千寻-Django表单验证

Django表单验证

普通表单验证；
模型表单验证；

一、普通表单验证

普通表单验证其实就是针对不同的Field字段进行针对性的验证。一般都是分为几个步骤：

Field的to_python方法；表单value转换为python对象，每个Field子类都重构了该方法；
Field的validate方法；对于这个方法，官网给出的说法是：当你遇到不可以或不想放在validator 中的验证逻辑时，应该覆盖它来处理验证。
Field的run_validator方法；这步骤主要是验证各种验证器

Field的clean方法会按顺序执行这三个方法：

  def to_python(self, value):
        return value

    def validate(self, value):
        if value in self.empty_values and self.required:
            raise ValidationError(self.error_messages['required'], code='required')

    def run_validators(self, value):
        if value in self.empty_values:
            return
        errors = []
        for v in self.validators:
            try:
                v(value)
            except ValidationError as e:
                if hasattr(e, 'code') and e.code in self.error_messages:
                    e.message = self.error_messages[e.code]
                errors.extend(e.error_list)
        if errors:
            raise ValidationError(errors)

    def clean(self, value):
        """
        Validates the given value and returns its "cleaned" value as an
        appropriate Python object.

        Raises ValidationError for any errors.
        """
        value = self.to_python(value)
        self.validate(value)
        self.run_validators(value)
        return value

BaseForm实现了is_valid基本方法：


@html_safe
@python_2_unicode_compatible
class BaseForm(object):

..........

    @property
    def errors(self):
        "Returns an ErrorDict for the data provided for the form"
        if self._errors is None:
            self.full_clean()
        return self._errors

    def is_valid(self):
        """
        Returns True if the form has no errors. Otherwise, False. If errors are
        being ignored, returns False.
        """
        return self.is_bound and not self.errors

代码很明显,is_valid访问self.errors，该方法是被描述符property修饰的，它会调用full_clean法，看代码：

class BaseForm:

    def full_clean(self):
       
        self._errors = ErrorDict()
       
        self.cleaned_data = {}
        
        self._clean_fields()
        self._clean_form()
        self._post_clean()

form的_clean_field最终会调用Field的clean方法：

     def _clean_fields(self):
       try:

                value = field.clean(value)
                self.cleaned_data[name] = value
            
            except ValidationError as e:
                self.add_error(name, e)

对于开发者，我们可以重构_post_clean等方法，或者自定义验证器等。

综述：代码调用情况：当form调用is_valid的时候最终就会调用Field的clean方法。调用顺序is_valid-->errors-->full_clean-->clean_fields。

其实到这，表单验证过程，还没有完呢，还有一个表单的clean_fieldname方法。该方法完成于特定属性相关的验证，这个验证与字段的类型无关。我们在下面讲。

二、模型表单验证

模型表单验证主要经历两个过程，一是和普通表单一样的表单验证，然后是模型验证。

普通表单在上面已经说了，主要说模型验证。

验证一个模型，要经历三个步骤：

验证模型的字段 Models.clean_fields()；
验证模型的完整性 Models.clean()；
验证模型的唯一性 Models.validate_unique()。

验证模型的字段，包括required,invalid,max_length等等是否有效；

验证唯一性是如果有些字段是唯一健，或者主键，那么如果填写字段颖存在了，就会抛出错误，看代码：

def unique_error_message(self, model_class, unique_check):
        opts = model_class._meta

        params = {
            'model': self,
            'model_class': model_class,
            'model_name': six.text_type(capfirst(opts.verbose_name)),
            'unique_check': unique_check,
        }

        # A unique field
        if len(unique_check) == 1:
            field = opts.get_field(unique_check[0])
            params['field_label'] = six.text_type(capfirst(field.verbose_name))
            return ValidationError(
                message=field.error_messages['unique'],
                code='unique',
                params=params,
            )

如果字段值已经出现过，那么就会抛出一个验证错误，看上面代码，返回的信息是field字段的errormessage，因此你完全可以自定义此类消息的内容。我自己在项目中也定义了。当用户名已经存在的时候，就会抛出错误信息：


class CustomUserCreationForm(UserCreationForm):
   
    error_messages = {
        'password_mismatch': u"两次新密码不匹配",
   }
   
    class Meta(UserCreationForm.Meta):
        model = User
        fields = UserCreationForm.Meta.fields + ('email',)
        error_messages = {
            'username': {
                    'unique': u"用户名已经注册，请更改用户名",
                   },
        }

当你填写一个已经存在的用户名的时候，虽然表单验证通过了，但模型验证未通过，这时就会抛出错误信息了。

在上面的普通表单验证中，我们提到了类方法调用关系，当在视图类中调用form.is_valid之后，就会调用form的full_clean方法，然后该方法调用了_post_clean,ModelForm对此进行了重构，看下源代码：

ModelForm继承自BaseForm，，ModelForm对此方法进行了重构：

class BaseModelForm:

 def _post_clean(self):
        opts = self._meta

        try:
            self.instance.full_clean(exclude=exclude, validate_unique=False)
        except ValidationError as e:
            self._update_errors(e)

Bingo!这段代码显示调用了模型实例的full_clean方法，full_clean方法将会执行clean_fields,clean,validate_unique等方法进行验证。：

来吧，让我们看下Model的代码吧：

Class Model：
 
   def full_clean(self, exclude=None, validate_unique=True):
        """
        Calls clean_fields, clean, and validate_unique, on the model,
        and raises a ``ValidationError`` for any errors that occurred.
        """
        errors = {}
        if exclude is None:
            exclude = []
        else:
            exclude = list(exclude)

        try:
            self.clean_fields(exclude=exclude)
        except ValidationError as e:
            errors = e.update_error_dict(errors)

        # Form.clean() is run even if other validation fails, so do the
        # same with Model.clean() for consistency.
        try:
            self.clean()
        except ValidationError as e:
            errors = e.update_error_dict(errors)

        # Run unique checks, but only for fields that passed validation.
        if validate_unique:
            for name in errors.keys():
                if name != NON_FIELD_ERRORS and name not in exclude:
                    exclude.append(name)
            try:
                self.validate_unique(exclude=exclude)
            except ValidationError as e:
                errors = e.update_error_dict(errors)

        if errors:
            raise ValidationError(errors)

上面讲了一大堆关于表单验证和模型验证的，细心的人可能会注意到，你一般都是对单个字段的验证，如果我还想验证和字段本身类型无关，而是字段间某种关联性的时候，该怎么办呢？

就比如说，上面的密码，两次密码要一直，不一致就会抛出错误，那到底是怎么实现的呢？其实就是用到了在第一小节提到的clean_fieldname方法。

在UserCreattionForm有一个方法是clean_password2方法:


class UserCreationForm(forms.ModelForm):

    def clean_password2(self):
        password1 = self.cleaned_data.get("password1")
        password2 = self.cleaned_data.get("password2")
        if password1 and password2 and password1 != password2:
            raise forms.ValidationError(
                self.error_messages['password_mismatch'],
                code='password_mismatch',
            )

该方法是用来验证密码是否一致，如果不一致就抛出错误。那该方法是如何调用的呢？

在上面我们说到，form.is_valid()会调用_clean_field，除了处理单个字段，还有一段代码：

def _clean_fields(self):
           try:
              for name, field in self.fields.items():
           
                value = field.clean(value)
                self.cleaned_data[name] = value
                if hasattr(self, 'clean_%s' % name):
                    value = getattr(self, 'clean_%s' % name)()
                    self.cleaned_data[name] = value
            except ValidationError as e:
                self.add_error(name, e)

看到没？hasattr(self,'clean_%s'%name)

如果存在clean_fieldname,就会执行该方法进行验证。牛逼吧？！！！

Django真的是太牛逼了！！！

再说下User的密码验证。Django提供了内置的验证器，具体配置在settings.py中：

AUTH_PASSWORD_VALIDATORS = [
    {
        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
    },
]

User在save时，会根据配置的密码验证器来验证密码，看一下源代码：

def get_password_validators(validator_config):
    validators = []
    for validator in validator_config:
        try:
            klass = import_string(validator['NAME'])
        except ImportError:
            msg = "The module in NAME could not be imported: %s. Check your AUTH_PASSWORD_VALIDATORS setting."
            raise ImproperlyConfigured(msg % validator['NAME'])
        validators.append(klass(**validator.get('OPTIONS', {})))

    return validators


def validate_password(password, user=None, password_validators=None):
    """
    Validate whether the password meets all validator requirements.

    If the password is valid, return ``None``.
    If the password is invalid, raise ValidationError with all error messages.
    """
    errors = []
    if password_validators is None:
        password_validators = get_default_password_validators()
    for validator in password_validators:
        try:
            validator.validate(password, user)
        except ValidationError as error:
            errors.append(error)
    if errors:
        raise ValidationError(errors)

内置的密码验证器，包括长度最短验证等：

UserAttributeSimilarityValidator , 验证和别的用户的相似性
MinimumLengthValidator , 验证最短长度，默认是9.
CommonPasswordValidator ,验证师傅出现在常见的比较差的密码列表中。
NumericPasswordValidator ,验证是否都是数字，不能裙式数字

你自己完全可以自定义的。我写了一个MinimumLengthValidator的子类，就是我想用汉语。


from django.contrib.auth.password_validation import MinimumLengthValidator
from django.core.exceptions import ImproperlyConfigured, ValidationError


class MinLenValidator(MinimumLengthValidator):

    def validate(self, password, user=None):
        if len(password) < self.min_length:
            raise ValidationError(
                '密码长度太短，至少要8个字符！',
                code='password_too_short',
                params={'min_length': self.min_length},
            )

其实很简单，除了Django内置的验证器，你可以自定义任何你想要的验证器。

--------EOF---------
微信分享/微信扫码阅读

Django表单验证

Django表单验证

一、普通表单验证

二、模型表单验证

登录

Sign Up

Forgotten Password