看用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如何自定义实现表单验证的主要内容，如果未能解决你的问题，请参考以下文章