看用Tornado如何自定义实现表单验证

Posted 财经知识狂魔

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了看用Tornado如何自定义实现表单验证相关的知识,希望对你有一定的参考价值。

  我们知道,平时在登陆某个网站或软件时,网站对于你输入的内容是有要求的,并且会对你输入的错误内容有提示,对于Django这种大而全的web框架,是提供了form表单验证功能,但是对于Tornado而言,就没有这功能,所以就需要我们来自己自定义form表单验证,而且这种方法正是Django里的form表单验证的实质内容,也帮我们在后面学习Django理解相关的源码。

 

  写之前,我们必须知道form表单验证的实质是什么?

   实质就是正则匹配

  我们知道用户提交数据是通过post方式提交,所以我们重写post方法,并在post方法进行业务逻辑处理

  • 获取用户提交的数据
  • 将用户提交的数据和正则表达式匹配

 

第一阶段

  • 场景:我们知道后台是一个url对应一个类来处理客户请求的
  • 问题:那么在不同页面里会相同需求,比如登陆时用邮箱登陆,修改密码时又要用邮箱,那对于这样同样验证需求,在我们的后台是不是代码就重复了呢?
  • 解决:独立一个模块专门用于用户信息验证

我们先看一下下面这段代码

class MainForm(object):
    def __init__(self):
        # 各种信息正则匹配规则
        # 并且要求这里字段名和前端传来的name一致
        self.host = "(.*)"
        self.ip = "^(25[0-5]|2[0-4]\\d|[0-1]?\\d?\\d)(\\.(25[0-5]|2[0-4]\\d|[0-1]?\\d?\\d)){3}$"
        self.port = \'(\\d+)\'
        self.phone = \'^1[3|4|5|8][0-9]\\d{8}$\'

    def check_valid(self, request):
        flag = True
        form_dict = self.__dict__  #获取类的普通字段和值
        for key, regular in form_dict.items():
            post_value = request.get_argument(key)  #获取用户输入的值
            # 让提交的数据 和 定义的正则表达式进行匹配
            ret = re.match(regular, post_value)
            print key,ret,post_value
            if not ret:
                flag = False  #一旦有匹配不成功的,设置为False
        return flag  #post方法里根据这个返回值来决定给客户返回什么内容

 

 从上面我们可以知道,这个模块只是简简单单的给了true  or false返回值的问题,我们还希望返回客户输入的值,看下怎么优化吧

  • 在check_vaild方法里定义一个局部变量-字典,然后接收客户的信息,并把这个字典一并返回到post方法里

 

第二阶段

  在上面,我们已经独立了一个模块来验证信息,但问题又来了,上面这个模块我定义的时候以index页面定制的,不同的页面处理的需要是不一样的,那如果解决这个问题,好像可以每个页面都独立一个模块,但这样,代码未免重复的太多了。

  仔细的人会发现,其实就是init里需要匹配的内容不一样,下面的check_vaild方法都是一样的

  • 类的继承,写一个BaseForm父类,让其他验证类继承

class BaseForm:
    def check_valid(self, handle):
        flag = True
        value_dict = {}
        for key, regular in self.__dict__.items():
            # host,ip port phone
            input_value = handle.get_argument(key)
            val = re.match(regular, input_value)
            print(key, input_value, val, regular)
            if not val:
                flag = False
            value_dict[key] = input_value
        return flag, value_dict


class IndexForm(BaseForm):
    def __init__(self):
        self.host = "(.*)"
        self.ip = "^(25[0-5]|2[0-4]\\d|[0-1]?\\d?\\d)(\\.(25[0-5]|2[0-4]\\d|[0-1]?\\d?\\d)){3}$"
        self.port = \'(\\d+)\'
        self.phone = \'^1[3|4|5|8][0-9]\\d{8}$\'


class HomeForm(BaseForm):
    def __init__(self):
        self.host = "(.*)"
        self.ip = "^(25[0-5]|2[0-4]\\d|[0-1]?\\d?\\d)(\\.(25[0-5]|2[0-4]\\d|[0-1]?\\d?\\d)){3}$"

   在实际场景中,客户填写的信息有些是必填,有些是可不填,这样又增加了匹配的复杂度,我们可不可以把每种匹配规则独立成一个类,并达到后台传入True时,不为空,传入了False时可为空呢??并且我们让这个类处理时返回错误提示信息??

class IPFiled:
    REGULAR = "^(25[0-5]|2[0-4]\\d|[0-1]?\\d?\\d)(\\.(25[0-5]|2[0-4]\\d|[0-1]?\\d?\\d)){3}$"

    def __init__(self, error_dict=None, required=True):
        self.error_dict = {}  #用于自定制错误提醒信息
        if error_dict:
            self.error_dict.update(error_dict)
        self.required = required  #可空否
        self.error = None      #记录错误提醒信息
        self.is_valid = False  #匹配成功与否
        self.value = None       #用户发来进行匹配的值

    def validate(self, name, input_value):
        \'\'\'
        :param name: 字段名:IP   方便在错误信息里提示
        :param input_value:用户输入的值
        :return:
        \'\'\'
        if not self.required:
            #可以为空--》通过
            self.is_valid = True
            self.value = input_value
        else:
            if not input_value.strip():
                #输入为空
                if self.error_dict.get(\'required\',None):
                    #使用自定义错误信息
                    self.error = self.error_dict[\'required\']
                else:
                    #使用默认
                    self.error = "%s is required" % name
            else:
                ret = re.match(IPFiled.REGULAR, input_value)
                if ret:
                    #匹配成功--》通过
                    self.id_valid = True
                    self.value = ret.group()
                else:
                    if self.error_dict.get(\'valid\', None):
                        #获取自定义错误信息,并使用
                        self.error = self.error_dict[\'valid\']
                    else:
                        #使用默认
                        self.error = "%s is invalid" % name

class BaseForm:
    def check_valid(self, handle):
        flag = True
        success_value_dict = {}
        error_message_dict = {}
        for key, regular in self.__dict__.items():
            #key-->ip  handle-->homeHandler对象  regular--》IPFiled对象
            input_value = handle.get_argument(key)  #用户输入的值
            #将验证放在了IPFiled对象里
            regular.validate(key,input_value)
            if regular.is_valid:
                #匹配成功就添加用户输入值
                success_value_dict[key] = regular.value
            else:
                #添加错误提示信息
                error_message_dict[key] = regular.error
                flag = False
        return flag, error_message_dict,success_value_dict

class HomeForm(BaseForm):
    def __init__(self):
        self.ip = IPFiled(required=True,error_dict={"required":"别闹","valid":"妹子,格式错了"})

class HomeHandler(tornado.web.RequestHandler):
    def get(self):
        self.render(\'home.html\')

    def post(self, *args, **kwargs):
        obj = HomeForm()
        # 获取用户输入的内容
        # 和正则表达式匹配
        is_valid,error_dict,success_dict = obj.check_valid(self)
        print(is_valid)
        if is_valid:
            print(success_dict)
        else:
            print(error_dict)

 

 

第三阶段

  在input类型有个叫checkbox的,在后台获取值不再是get_argument,而是get_arguments,不同于其他的input类型,所以在BaseForm的check_valid方法里获取值的方式就要改了,利用type进行判断

class BaseForm:
    def check_valid(self, handle):
        flag = True
        error_message_dict = {}
        success_value_dict = {}
        for key, regular in self.__dict__.items():
            # key: ip .....
            # handle: HomeIndex对象,self.get_... self.
            # regular: IPFiled(required=True)

            if type(regular) == ChechBoxFiled:
                input_value = handle.get_arguments(key)  #get_arguments是没有默认参数的
            else:
                input_value = handle.get_argument(key)
            # input_value = 用户输入的值
            # 将具体的验证,放在IPFiled对象中
            regular.validate(key, input_value)

            if regular.is_valid:
                success_value_dict[key] = regular.value
            else:
                error_message_dict[key] = regular.error
                flag = False

   另外对checkbox返回结果处理方式也稍微有些区别,不用对其合法性检测,只要判断是否为空即可,所以在CheckBoxFiled类的validate方法也要改

class CheckBoxFiled:

    def __init__(self, error_dict=None, required=True):
        # 封装了错误信息
        self.error_dict = {}
        if error_dict:
            self.error_dict.update(error_dict)

        self.required = required

        self.error = None # 错误信息
        self.value = None
        self.is_valid = False

    def validate(self, name, input_value):
        """
        :param name: 字段名 favor
        :param input_value: 用户表单中输入的内容,列表None or [1,2]
        :return:
        """

        if not self.required:
            # 用户输入可以为空
            self.is_valid = True
            self.value = input_value
        else:
            if not input_value:
                #不应为空,而空了,提示错误信息
                if self.error_dict.get(\'required\',None):
                    #获取自定制信息
                    self.error = self.error_dict[\'required\']
                else:
                    #取默认的
                    self.error = "%s is required" % name
            else:
                self.is_valid = True
                self.value = input_value

 

第四阶段

  除了checkbox这个特殊外,还有file----文件上传,在后台获取方式也不一样,不是self.get_argument,而是self.request.files.get(),得到的内容是一个列表,格式如 [{\'body\':\'xx\',\'filename\':\'xx\'},{\'body\':\'xx\',\'filename\':\'xx\'}],想要获得文件名,还要循环这个列表,通过filename的key取到,并且我们如果要把文件上传到服务端,就在FileFiled写入save方法,“body”里面就是文件内容

import tornado.ioloop
import tornado.web
import re
import os

class IPFiled:
    REGULAR = "^(25[0-5]|2[0-4]\\d|[0-1]?\\d?\\d)(\\.(25[0-5]|2[0-4]\\d|[0-1]?\\d?\\d)){3}$"

    def __init__(self, error_dict=None, required=True):
        # 封装了错误信息
        self.error_dict = {}
        if error_dict:
            self.error_dict.update(error_dict)

        self.required = required

        self.error = None # 错误信息
        self.value = None
        self.is_valid = False

    def validate(self, name, input_value):
        """
        :param name: 字段名
        :param input_value: 用户表单中输入的内容
        :return:
        """
        if not self.required:
            # 用户输入可以为空
            self.is_valid = True
            self.value = input_value
        else:
            if not input_value.strip():
                if self.error_dict.get(\'required\',None):
                    self.error = self.error_dict[\'required\']
                else:
                    self.error = "%s is required" % name
            else:
                ret = re.match(IPFiled.REGULAR, input_value)
                if ret:
                    self.is_valid = True
                    self.value = input_value
                else:
                    if self.error_dict.get(\'valid\', None):
                        self.error = self.error_dict[\'valid\']
                    else:
                        self.error = "%s is invalid" % name

class StringFiled:
    REGULAR = "^(.*)$"

    def __init__(self, error_dict=None, required=True):
        # 封装了错误信息
        self.error_dict = {}
        if error_dict:
            self.error_dict.update(error_dict)

        self.required = required

        self.error = None # 错误信息
        self.value = None
        self.is_valid = False

    def validate(self, name, input_value):
        """
        :param name: 字段名
        :param input_value: 用户表单中输入的内容
        :return:
        """
        if not self.required:
            # 用户输入可以为空
            self.is_valid = True
            self.value = input_value
        else:
            if not input_value.strip():
                if self.error_dict.get(\'required\',None):
                    self.error = self.error_dict[\'required\']
                else:
                    self.error = "%s is required" % name
            else:
                ret = re.match(IPFiled.REGULAR, input_value)
                if ret:
                    self.is_valid = True
                    self.value = input_value
                else:
                    if self.error_dict.get(\'valid\', None):
                        self.error = self.error_dict[\'valid\']
                    else:
                        self.error = "%s is invalid" % name

class ChechBoxFiled:

    def __init__(self, error_dict=None, required=True):
        # 封装了错误信息
        self.error_dict = {}
        if error_dict:
            self.error_dict.update(error_dict)

        self.required = required

        self.error = None # 错误信息
        self.value = None
        self.is_valid = False

    def validate(self, name, input_value):
        """
        :param name: 字段名 favor
        :param input_value: 用户表单中输入的内容,列表None or [1,2]
        :return:
        """

        if not self.required:
            # 用户输入可以为空
            self.is_valid = True
            self.value = input_value
        else:
            if not input_value:
                if self.error_dict.get(\'required\',None):
                    self.error = self.error_dict[\'required\']
                else:
                    self.error = "%s is required" % name
            else:
                self.is_valid = True
                self.value = input_value

class FileFiled:

    REGULAR = "^(\\w+\\.pdf)|(\\w+\\.mp3)|(\\w+\\.py)$"

    def __init__(self, error_dict=None, required=True):
        # 封装了错误信息
        self.error_dict = {}
        if error_dict:
            self.error_dict.update(error_dict)

        self.required = required

        self.error = None  # 错误信息
        self.value = []
        self.is_valid = True
        self.name = None
        self.success_file_name_list = []

    def validate(self, name, all_file_name_list):
        """
        :param name: 字段名
        :param all_file_name_list: 所有文件文件名
        :return:
        """
        self.name = name
        if not self.required:
            # 用户输入可以为空
            self.is_valid = True
            self.value = all_file_name_list
        else:
            #用户输入不能为空
            if not all_file_name_list:
                #输入为空
                self.is_valid = False
                if self.error_dict.get(\'required\',None):
                    self.error = self.error_dict[\'required\']
                else:
                    self.error = "%s is required" % name
            else:
                # 循环所有的文件名
                for file_name in all_file_name_list:
                    ret = re.match(FileFiled.REGULAR, file_name)
                    if not ret:
                        #有文件名匹配不成功
                        self.is_valid = False
                        if self.error_dict.get(\'valid\', None):
                            self.error = self.error_dict[\'valid\']
                        else:
                            self.error = "%s is invalid" % name
                        break
                    else:
                        self.value.append(file_name)  #都匹配成功的文件名列表

    def save(self, request, path=\'statics\'):
        # 所有文件列表
        # request = HomeHandler.request  self.name = fafafa(前端名字)
        file_metas = request.files.get(self.name)
        # 循环文件列表
        temp_list = []
        for meta in file_metas:
            # 每一个文件的文件名
            file_name = meta[\'filename\']
            # self.value:[1.py, 2.py]  【statics/1.py  statics/2.py】
            new_file_name = os.path.join(path, file_name)
            #self.value--->success_file_name_list
            if file_name and file_name in self.value:
                temp_list.append(new_file_name)
                with open(new_file_name, \'wb\') as up:
                    up.write(meta[\'body\'])
        self.value = temp_list

class BaseForm:
    def check_valid(self, handle):
        flag = True
        error_message_dict = {}
        success_value_dict = {}
        for key, regular in self.__dict__.items():
            # key: ip .....
            # handle: HomeIndex对象,self.get_... self.
            # regular: IPFiled(required=True)

            if type(regular) == ChechBoxFiled:
                input_value = handle.get_arguments(key)
            elif type(regular) == FileFiled:
                # 获取文件名
                file_list = handle.request.files.get(key)
                # [{\'body\':\'xx\',\'filename\':\'xx\'},{\'body\':\'xx\',\'filename\':\'xx\'}]
                input_value = []  #file_name_list
                for item in file_list:
                    input_value.append(item[\'filename\'])
                # 所有文件名进行验证
            else:
                input_value = handle.get_argument(key)
            # input_value = 用户输入的值
            # 将具体的验证,放在IPFiled对象中
            regular.validate(key, input_value)

            if regular.is_valid:
                success_value_dict[key] = regular.value
            else:
                error_message_dict[key] = regular.error
                flag = False

        return flag, success_value_dict, error_message_dict

class HomeForm(BaseForm):
    def __init__(self):
        self.ip = IPFiled(required=True, error_dict={\'required\': "别闹,别整空的..", "valid": "骚年,格式错误了"})
        self.host = StringFiled(required=False)
        self.favor = ChechBoxFiled(required=True)
        self.fafafa = FileFiled(required=True)  #前端name同名fafafa

class HomeHandler(tornado.web.RequestHandler):
    def get(self):
        self.render(\'home.html\', error_dict=None)

    def post(self, *args, **kwargs):

        # self.get_argument()
        # self.get_arguments()
        # files = self.request.files.get(\'fafafa\',[])
        # # files = [ 文件一、文件二]
        # print(type(files),files)

        obj = HomeForm()
        is_valid, success_dict, error_dict = obj.check_valid(self)
        if is_valid:
            print(\'success\',success_dict)
            #只有全部通过,就执行上传方法
            obj.fafafa.save(self.request)  #HomeForm().fafafa=FileFiled()
        else:
            print(\'error\', error_dict)
            self.render(\'home.html\', error_dict=error_dict)

settings = {
    \'template_path\': \'views\',
    \'static_path\': \'statics\',
    \'static_url_prefix\': \'/statics/\',
}

application = tornado.web.Application([
    (r"/home", HomeHandler),
], **settings)


if __name__ == "__main__":
    application.listen(8001)
    tornado.ioloop.IOLoop.instance().start()

 

  是不是有点乱,这么多类,好!这里画个小图,助于大家理解.....

   是不是还是不好理解,好把,我画图有限...

以上是关于看用Tornado如何自定义实现表单验证的主要内容,如果未能解决你的问题,请参考以下文章

tornado1

iview 自定义验证表单多层嵌套如何实现

抽屉之Tornado实战--form表单验证

jquery表单验证 自定义函数使用

vue + element 实现登录注册(自定义表单验证规则)

自定义laravel表单请求验证类(FormRequest共用一个rules())