python-flask-wtforms组件流程源码

　　在最开始要弄明白一点，类都是由元类创建的。在定义类 class Foo：pass的时候（类也是对象），就会执行type类或者type派生类的__init__方法，当Foo（）时：执行type类或者type派生类的__call__方法，在__call__方法中调用了Foo类的__new__方法创建了一个对象，接着执行__init__方法为这个创建的对象进行赋值属性。

from flask import Flask, render_template, request, redirect
from wtforms import Form
from wtforms.fields import core
from wtforms.fields import html5
from wtforms.fields import simple
from wtforms import widgets
from wtforms import validators

app = Flask(__name__, template_folder='templates')
app.debug = True

#0 定义LogonForm类
class LoginForm(Form):
　　 #1 StringField类的实例化
    name = simple.StringField(
        label='用户名',
        validators=[
            validators.DataRequired(message='用户名不能为空.'),
            validators.Length(min=6, max=18, message='用户名长度必须大于%(min)d且小于%(max)d')
        ],
        widget=widgets.TextInput(),
        render_kw={'class': 'form-control'}
    )
 
    pwd = simple.PasswordField(
        label='密码',
        validators=[
            validators.DataRequired(message='密码不能为空.'),
            validators.Length(min=8, message='用户名长度必须大于%(min)d'),
            validators.Regexp(regex="^(?=.*[a-z])(?=.*[A-Z])(?=.*d)(?=.*[$@$!%*?&])[A-Za-zd$@$!%*?&]{8,}",
                              message='密码至少8个字符，至少1个大写字母，1个小写字母，1个数字和1个特殊字符')
        ],
        widget=widgets.PasswordInput(),
        render_kw={'class': 'form-control'}
    )

    class Meta:
        csrf = False

    def validate_pwd(self,*args,**kwargs):
        pass


@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'GET':
　　　　 #2.实例化一个LoginForm对象
        form = LoginForm()
　　　　 #第3步
　　　　 # print(form.name)
        return render_template('login.html', form=form)
    else:
　　　　　#2.3步
        form = LoginForm(formdata=request.form)
　　　　　#4步，验证
        if form.validate():
            print('用户提交数据通过格式验证，提交的值为：', form.data)
        else:
            print(form.errors)
        return render_template('login.html', form=form)

def test():
    form = LoginForm()


if __name__ == '__main__':
    app.run()

第0步：

在定义LoginForm类的时候我们看看发生了什么

首先我们要知道metaclass的另外一种方式：with_metaclass

metaclass的另外一种方式：
    class MyType(type):
        def __init__(self,*args,**kwargs):
            print('xxxx')
            super(MyType,self).__init__(*args,**kwargs)

        def __call__(cls, *args, **kwargs):
            obj = cls.__new__(cls,*args, **kwargs)
            cls.__init__(obj,*args, **kwargs) # Foo.__init__(obj)
            return obj

    def with_metaclass(base):
        return MyType("MyType",(base,),{})

    class Foo(with_metaclass(object)):
        def __init__(self,name):
            self.name = name

    #打印结果：  xxxx    xxxx

所以我们去Form中找找，发现了metaclass的另外一种方式

class Form(with_metaclass(FormMeta, BaseForm)):
    pass

我们再去with_metaclass看看

def with_metaclass(meta, base=object):
    return meta("NewBase", (base,), {})
　　 # FormMeta("NewBase", (BaseForm,), {})    # 通过FormMeta创建了一个NewBase类，NewBase类继承了BaseForm类
　　 # 那你有没有疑问，为什么 FormMeta类可以创建类呢？  我们去FormMeta类看看

class FormMeta(type):
　　pass
#发现FormMeta继承了type类，所以刚才我们的疑问迎刃而解。

那就是说当LoginForm定义的时候执行了FormMeta类的__init__方法

class FormMeta(type):
    def __init__(cls, name, bases, attrs):
        type.__init__(cls, name, bases, attrs)
        cls._unbound_fields = None
        cls._wtforms_meta = None

这步完成后 LoginForm类有两个属性：cls._unbound_fields = None和  cls._wtforms_meta = None

第1步：实例化StringField类的对象，首先应该去StringField中找__new__方法

class StringField(Field):
    pass
#发现StringField类中没有，那我们就去基类中

class Field(object):
        def __new__(cls, *args, **kwargs):
　　　　　　　#判断不成立，走else
        　　if '_form' in kwargs and '_name' in kwargs:
            　　return super(Field, cls).__new__(cls)
        　　else:
　　　　　　　　　#返回一个UnboundField对象
            　　return UnboundField(cls, *args, **kwargs)  # cls = simple.StringField 这个类

class UnboundField(object):
    _formfield = True
    creation_counter = 0
    def __init__(self, field_class, *args, **kwargs):
        UnboundField.creation_counter += 1
        self.field_class = field_class    # self.field_class = simple.StringField
        self.args = args
        self.kwargs = kwargs
        self.creation_counter = UnboundField.creation_counter    #这个数字，在后面会根据这个进行排序

这步完成后，我们知道 LoginForm的 name和pwd字段都等于UnboundField 的对象

第2步：实例化LoginForm的对象会执行FormMeta的__call__方法

class FormMeta(type):
    def __call__(cls, *args, **kwargs):
        if cls._unbound_fields is None:
            fields = []
            #获取LoginForm类中的所有字段
            for name in dir(cls):
                if not name.startswith('_'):
                    #获取该字段的值
                    unbound_field = getattr(cls, name)  #unbound_field 是一个UnboundField对象
                    if hasattr(unbound_field, '_formfield'):         #    _formfield = True
                        fields.append((name, unbound_field))         # [("name",UnboundField对象),("pwd",UnboundField对象)]
            fields.sort(key=lambda x: (x[1].creation_counter, x[0]))  #根据UnboundField对象的creation_counter属性对fields列表进行排序
            cls._unbound_fields = fields                             # LoginForm._unbound_fields = [("name",UnboundField对象),("pwd",UnboundField对象)]

        if cls._wtforms_meta is None:
            bases = []
            for mro_class in cls.__mro__:   #循环当前类和基类组成的元组
                if 'Meta' in mro_class.__dict__:   #如果类中有Meta类，就把Meta类添加到 bases列表中
                    bases.append(mro_class.Meta)
            cls._wtforms_meta = type('Meta', tuple(bases), {})    #LoginForm._wtforms_meta = 一个新的Meta类，它继承了所有的Meta类，这样做好处在于：通过新Meta类可以取到无论是LoginForm或者LoginForm基类中的任何Meta类
        return type.__call__(cls, *args, **kwargs)

接着到LoginForm或基类中找__new__方法，发现都没有，那就继续找LoginForm或基类中的__init__方法

class Form(with_metaclass(FormMeta, BaseForm)):
    Meta = DefaultMeta
    
    def __init__(self, formdata=None, obj=None, prefix='', data=None, meta=None, **kwargs):
        meta_obj = self._wtforms_meta()
　　　　 #2.1 执行父类的__init__方法
        super(Form, self).__init__(self._unbound_fields, meta=meta_obj, prefix=prefix)
　　　　 #2.2
        for name, field in iteritems(self._fields):
　　　　　　　#这个self是LoginForm对象
            setattr(self, name, field)
　　　　 #2.3步
        self.process(formdata, obj, data=data, **kwargs)

这时候要注意：Form的基类是with_metaclass函数创建的 NewBase类，NewBase类继承了BaseForm类

所以第2.1步：执行了BaseForm类的__init__方法

class BaseForm(object):
    #这个self是LoginForm对象
    def __init__(self, fields, prefix='', meta=DefaultMeta()):
        self.meta = meta              #meta是新创建的Meta类的对象
        self._fields = OrderedDict()

        extra_fields = []
        #从这句话我们可以看出 在自定义LoginForm中的Meta类内可以写字段： csrf = False
        if meta.csrf:
            self._csrf = meta.build_csrf(self)
            extra_fields.extend(self._csrf.setup_form(self))
        #第2.1.1步
        for name, unbound_field in itertools.chain(fields, extra_fields):
　　　　　　　#name 是LoginForm中的字段，unbound_field是 UnboundField对象
            field = meta.bind_field(self, unbound_field, options)
　　　　　　　#第2.1.2步： 到有序字典中赋值
            self._fields[name] = field  # {"name":simple.StringField类对象,"pwd":simple.PasswordField类对象}

第2.1.1步：执行meta.bind_field方法

class DefaultMeta(object):
    def bind_field(self, form, unbound_field, options):
　　　　 #2.1.1.1   form是LoginFrom对象
        return unbound_field.bind(form=form, **options)

在 这里你没有疑问：meta是新创建的Meta类对象，为什么会执行 DefaultMeta类的bind_field方法呢？

那是因为新Meta类继承了 LoginForm类和其基类中的所有Meta类

class Form(with_metaclass(FormMeta, BaseForm)):
    Meta = DefaultMeta

看到上面这段代码之后你就明白为什么会跑到DefaultMeta类中找方法了吧

第2.1.1.1步：

class UnboundField(object):
    def bind(self, form, name, prefix='', translations=None, **kwargs):
        #就是在这步把_form当参数传进field_class方法
        kw = dict(
            self.kwargs,
            _form=form,
            _prefix=prefix,
            _name=name,
            _translations=translations,
            **kwargs
        )
　　　　　#2.1.1.1.1步
        return self.field_class(*self.args, **kw)
　　　　　　     #在第1步中我们可以看到  self.field_class = simple.StringField

把各自字段相应的类实例化的对象返回给2.1.1步，然后又赋值给了 field 变量

第2.1.1.1.1步：执行simple.StringField或其基类的__init__方法

class Field(object):
    def __init__(self, label=None, validators=None, filters=tuple(),
                 description='', id=None, default=None, widget=None,
                 render_kw=None, _form=None, _name=None, _prefix='',
                 _translations=None, _meta=None):
        if _meta is not None:
            self.meta = _meta
　　　　　#_form=form
        elif _form is not None:
            self.meta = _form.meta   #self.meta = form.meta = 新创建的Meta类对象
        else:
            raise TypeError("Must provide one of _form or _meta")
        self.render_kw = render_kw
        self.name = _prefix + _name
        self.type = type(self).__name__
        self.id = id or self.name

故，2.1步执行完成后     form(LoginForm对象)._fields["name"] = simple.StringField类对象

第2.2步：赋值操作

form.name=simple.StringField类对象
form.pwd=simple.PasswordField类对象

第2.3步：此步是实例化LoginForm时传值的情况分析

 根据此行代码我们可以看出，数据初始化传值有三种形式： 1.  data=字典, 2.  obj=对象.字段 ， 3. formdata=有getlist方法
 self.process(formdata, obj, data=data, **kwargs)
 例如：

 class User:
     def __init__(self,name):
         self.name = name
 obj = User('alex')

 form = LoginForm(data={'name':'alex'})
 form = LoginForm(obj=obj) 
 form = LoginForm(formdata=request.form/args)

class BaseForm(object):
    def process(self, formdata=None, obj=None, data=None, **kwargs):
　　　　 #第2.3.1步
        formdata = self.meta.wrap_formdata(self, formdata)
        if data is not None:
            kwargs = dict(data, **kwargs)

        for name, field, in iteritems(self._fields):
　　　　　　　#name = name ，field = simple.StringField类对象
　　　　　　　#传值第2种方式
            if obj is not None and hasattr(obj, name):
                field.process(formdata, getattr(obj, name))
　　　　　　  #传值第1种方式
            elif name in kwargs:
                field.process(formdata, kwargs[name])
　　　　　　　#传值第3种方式 
            else:
　　　　　　　　　 # 第 2.3.2步
                field.process(formdata)

第2.3.1步

class DefaultMeta(object):
    def wrap_formdata(self, form, formdata):
　　　　　#判断传进来的formdata有没有getlist方法
        if formdata is not None and not hasattr(formdata, 'getlist'):
            if hasattr(formdata, 'getall'):
                return WebobInputWrapper(formdata)
            else:
                raise TypeError("formdata should be a multidict-type wrapper that supports the 'getlist' method")
        return formdata

 第2.3.2步：

class Field(object):
　　 #self 是 field对象
    def process(self, formdata, data=unset_value):
　　　　　#formdata传值的方式：
        if formdata:
            try:
　　　　　　　　　　#获取值
                if self.name in formdata:
                    self.raw_data = formdata.getlist(self.name)
                else:
                    self.raw_data = []
　　　　　　　　　 #2.3.2.1
                self.process_formdata(self.raw_data)

第2.3.2.1步：

class Field(object):    
    def process_formdata(self, valuelist):
        if valuelist:
            self.data = valuelist[0]   #赋值给self.data

第3步：form.name 是如果在页面上显示出的 input 标签？

print(form.name)    #form.name = simple.StringField 类的对象
# 结果：<input class="form-control" id="name" name="name" type="text" value="">
#我们看到打印的结果是 input 标签，其实form.name结果不一定是它，我们去simple.StringField类或其基类中找找__str__方法

class Field(object):
    def __str__(self):
        return self()   #对象() ，执行__call__方法

class Field(object):
    def __call__(self, **kwargs):
        return self.meta.render_field(self, kwargs)  #第2.1.1.1.1步可以看出 self.meta 是新创建Meta类对象， self 是simple.StringField类对象

class DefaultMeta(object):
    def render_field(self, field, render_kw):
        #获取标签属性，field = simple.StringField类对象
        other_kw = getattr(field, 'render_kw', None)
        if other_kw is not None:
            render_kw = dict(other_kw, **render_kw)
            #{'class': 'form-control'}
            
        return field.widget(field, **render_kw)   
　　　　　　　　# class StringField(Field):
    　　　　　 #　　　　widget = widgets.TextInput()   #widget 是一个TextInput类的对象
　　　　　　　　# TextInput()()  执行__call__方法，去TextInput或基类中找

class Input(object):
    def __call__(self, field, **kwargs):
        kwargs.setdefault('id', field.id)
        kwargs.setdefault('type', self.input_type)
　　　　 #如果render_kw中没有给value定义值
        if 'value' not in kwargs:
　　　　　　　#3.1步
            kwargs['value'] = field._value()    #field 是 simple.StringField类对象
　　　　　#在这里，给input 标签添加属性，这样在页面上显示的标签就有了默认值
        return HTMLString('<input %s>' % self.html_params(name=field.name, **kwargs))

 第3.1步

class StringField(Field):
    def _value(self):
　　　　　#取self.data 中的值，返回
        return text_type(self.data) if self.data is not None else ''

 第4步：验证

class Form(with_metaclass(FormMeta, BaseForm)):
    def validate(self):
        extra = {}
        for name in self._fields:      #{"name":simple.StringField类对象,"pwd":simple.PasswordField类对象}
            #到 LoginForm类中获取钩子函数
            inline = getattr(self.__class__, 'validate_%s' % name, None)
            if inline is not None:
                #保存到extra字段中
                extra[name] = [inline]
        #执行Form基类的validate方法
        return super(Form, self).validate(extra)

class BaseForm(object):
    #self是LoginForm对象
    def validate(self, extra_validators=None):  #extra_validators是所有的钩子
        self._errors = None
        success = True
        for name, field in iteritems(self._fields):
            #如果钩子函数有值
            if extra_validators is not None and name in extra_validators:
                #获取钩子函数的验证规则
                extra = extra_validators[name]
            else:
                extra = tuple()
            #4.1执行字段的validate方法
            if not field.validate(self, extra):
                success = False
        return success

第4.1步

class Field(object):        
    def validate(self, form, extra_validators=tuple()):
        self.errors = list(self.process_errors)           #self.errors 是个列表，所以我们在前端页面上只显示一个
        stop_validation = False
        if not stop_validation:
　　　　　　　#把字段本身的校验规则和钩子规则放在一起
            chain = itertools.chain(self.validators, extra_validators)
            #4.1.1 执行字段的_run_validation_chain
            stop_validation = self._run_validation_chain(form, chain)     #如果校验未通过 stop_validation = True

　　　　　　　return len(self.errors) == 0

第4.1.1步

class Field(object):        
    def _run_validation_chain(self, form, validators):
        for validator in validators:
            try:
                #validator是validators.DataRequired类对象
                #4.1.1.1 对象()   调用__call__方法
                validator(form, self) 
　　　　　　　#4.1.1.2 如果校验出异常    
            except StopValidation as e:
                if e.args and e.args[0]:
　　　　　　　　　　　　#在该字段的errors列表中添加错误信息
                    self.errors.append(e.args[0])
                return True
            except ValueError as e:
                self.errors.append(e.args[0])
        return False

第4.1.1.1步：分别执行各个的校验规则类的__call__方法和钩子函数

class DataRequired(object):
    def __call__(self, form, field):
        #校验 该字段有数据并是字符串类型
        if not field.data or isinstance(field.data, string_types) and not field.data.strip():
            if self.message is None:
                message = field.gettext('This field is required.')
            else:
                message = self.message

            field.errors[:] = []
            #不然抛出异常
            raise StopValidation(message)

class Length(object):
    def __call__(self, form, field):
        l = field.data and len(field.data) or 0
        if l < self.min or self.max != -1 and l > self.max:
            message = self.message
            if message is None:
                if self.max == -1:
                    message = field.ngettext('Field must be at least %(min)d character long.',
                                             'Field must be at least %(min)d characters long.', self.min)
                elif self.min == -1:
                    message = field.ngettext('Field cannot be longer than %(max)d character.',
                                             'Field cannot be longer than %(max)d characters.', self.max)
                else:
                    message = field.gettext('Field must be between %(min)d and %(max)d characters long.')

            raise ValidationError(message % dict(min=self.min, max=self.max, length=l))

class Regexp(object):
    def __call__(self, form, field, message=None):
        match = self.regex.match(field.data or '')
        if not match:
            if message is None:
                if self.message is None:
                    message = field.gettext('Invalid input.')
                else:
                    message = self.message

            raise ValidationError(message)
        return match

def validate_pwd(self,*args,**kwargs):
        pass

解释说明：

　　如果校验成功，4.1.1.1步不抛出异常 →  4.1.1.2步不执行（self.errors没有值）→ 4.1.1步返回False → 4.1步返回True  → success=True  → 校验成功·

　　如果校验不成功，每个字段的 .errors里都有错误信息，可以在前端页面上显示出来·

　　注意：wtforms组件没有clean_data的概念，即使数据校验不成功，打印form.data也会打印出你输入的数据

#print(form.data)

class BaseForm(object):        
    @property
    def data(self):
        return dict((name, f.data) for name, f in iteritems(self._fields))

最后我们也可以自己定义一个Form：

from flask import Flask, render_template, request, redirect,Markup
app = Flask(__name__, template_folder='templates')
import wtforms
app.debug = True

# 插件
class Widget(object):
    pass

class InputText(Widget):

    def __call__(self, *args, **kwargs):
        return "<input type='text' name='name' />"

class TextArea(Widget):
    def __call__(self, *args, **kwargs):
        return "<textarea name='email'> </textarea>"

# Form
class BaseForm(object):
    def __init__(self):
        # 获取当前字段
        _fields = {}
        for name,field in self.__class__.__dict__.items():
            if isinstance(field,Field):
                _fields[name] = field
        self._fields = _fields
        self.data = {}


    def validate(self,request_data):
        # 找到所有的字段，执行每个字段的validate方法
        flag = True
        for name,field in self._fields.items():
            # 123
            input_val = request_data.get(name,'')
            result = field.validate(input_val)
            if not result:
                flag = False
            else:
                self.data[name] = input_val
        return flag
# 字段
class Field(object):

    def __str__(self):
        return Markup(self.widget())

class StringField(Field):
    widget = InputText()

    def validate(self,val):
        if val:
            return True

class EmailField(Field):
    widget = TextArea() # EmailField.widget/ self.widget
    reg = ".*@.*"

    def validate(self, val):
        import re
        if re.match(self.reg,val):
            return True

# ############################ 使用 ###########################
class LoginForm(BaseForm):
    name = StringField()
    email = EmailField()


@app.route('/login', methods=['GET', 'POST'])
def login():

    form = LoginForm()
    ret = form.validate(request.form)
    print("验证成功",ret)
    print("验证成功值",form.data)
    # print(obj.name)
    # print(obj.email)
    return render_template('login.html',form=form)

if __name__ == '__main__':
    app.run()